From 567381db9575b9e4907261880f0403150f749f68 Mon Sep 17 00:00:00 2001 From: Oleksandr Tarasiuk Date: Sun, 30 Aug 2026 00:21:35 +0300 Subject: [PATCH 1/8] feat: add iterator methods to esnext --- tsc/internal/bundled/embed_generated.go | 4 + tsc/internal/bundled/libs/lib.esnext.d.ts | 1 + .../bundled/libs/lib.esnext.iterator.d.ts | 116 ++++++++ tsc/internal/bundled/libs_generated.go | 1 + tsc/internal/compiler/program_test.go | 1 + tsc/internal/tsoptions/enummaps.go | 2 +- .../compiler/builtinIterator.symbols | 2 +- .../reference/compiler/builtinIterator.types | 12 +- .../reference/compiler/iteratorChunks.js | 14 + .../reference/compiler/iteratorChunks.symbols | 21 ++ .../reference/compiler/iteratorChunks.types | 36 +++ .../reference/compiler/iteratorIncludes.js | 21 ++ .../compiler/iteratorIncludes.symbols | 35 +++ .../reference/compiler/iteratorIncludes.types | 65 ++++ .../reference/compiler/iteratorJoin.js | 16 + .../reference/compiler/iteratorJoin.symbols | 27 ++ .../reference/compiler/iteratorJoin.types | 47 +++ .../reference/compiler/iteratorZip.js | 91 ++++++ .../reference/compiler/iteratorZip.symbols | 181 ++++++++++++ .../reference/compiler/iteratorZip.types | 279 ++++++++++++++++++ ...eplacement(libreplacement=true).trace.json | 13 + ...singDeclarationsWithIteratorObject.symbols | 2 +- ...tUsingDeclarationsWithIteratorObject.types | 4 +- ...singDeclarationsWithIteratorObject.symbols | 2 +- .../usingDeclarationsWithIteratorObject.types | 4 +- ...ig-with-incorrect-compiler-option-value.js | 2 +- .../reference/tsc/commandLine/help-all.js | 2 +- .../reference/tsc/commandLine/help.js | 2 +- ...when-host-cannot-provide-terminal-width.js | 2 +- ...tatus.DiagnosticsPresent_OutputsSkipped.js | 6 +- ...-config-file-absent-with---ignoreConfig.js | 2 +- ...out-any-options-when-config-file-absent.js | 2 +- ...ig-with-incorrect-compiler-option-value.js | 2 +- ...h-interval-option-without-tsconfig.json.js | 2 +- .../watch-handles-tsconfig-deleted.js | 2 +- .../Parse invalid option of library flags.js | 2 +- .../tests/cases/compiler/iteratorChunks.ts | 8 + .../tests/cases/compiler/iteratorIncludes.ts | 12 + .../tests/cases/compiler/iteratorJoin.ts | 9 + .../tests/cases/compiler/iteratorZip.ts | 57 ++++ 40 files changed, 1082 insertions(+), 27 deletions(-) create mode 100644 tsc/internal/bundled/libs/lib.esnext.iterator.d.ts create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorChunks.js create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorChunks.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorChunks.types create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorIncludes.js create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorIncludes.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorIncludes.types create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorJoin.js create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorJoin.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorJoin.types create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZip.js create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZip.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZip.types create mode 100644 tsc/testdata/tests/cases/compiler/iteratorChunks.ts create mode 100644 tsc/testdata/tests/cases/compiler/iteratorIncludes.ts create mode 100644 tsc/testdata/tests/cases/compiler/iteratorJoin.ts create mode 100644 tsc/testdata/tests/cases/compiler/iteratorZip.ts diff --git a/tsc/internal/bundled/embed_generated.go b/tsc/internal/bundled/embed_generated.go index 53166f01f98d9..4f9253dbdf6df 100644 --- a/tsc/internal/bundled/embed_generated.go +++ b/tsc/internal/bundled/embed_generated.go @@ -211,6 +211,8 @@ var ( libs_lib_esnext_full_d_ts string //go:embed libs/lib.esnext.intl.d.ts libs_lib_esnext_intl_d_ts string + //go:embed libs/lib.esnext.iterator.d.ts + libs_lib_esnext_iterator_d_ts string //go:embed libs/lib.esnext.sharedmemory.d.ts libs_lib_esnext_sharedmemory_d_ts string //go:embed libs/lib.esnext.temporal.d.ts @@ -330,6 +332,7 @@ var embeddedContents = map[string]string{ "libs/lib.esnext.error.d.ts": libs_lib_esnext_error_d_ts, "libs/lib.esnext.full.d.ts": libs_lib_esnext_full_d_ts, "libs/lib.esnext.intl.d.ts": libs_lib_esnext_intl_d_ts, + "libs/lib.esnext.iterator.d.ts": libs_lib_esnext_iterator_d_ts, "libs/lib.esnext.sharedmemory.d.ts": libs_lib_esnext_sharedmemory_d_ts, "libs/lib.esnext.temporal.d.ts": libs_lib_esnext_temporal_d_ts, "libs/lib.esnext.typedarrays.d.ts": libs_lib_esnext_typedarrays_d_ts, @@ -441,6 +444,7 @@ var libsEntries = []fs.DirEntry{ &fileInfo{name: "lib.esnext.error.d.ts", size: int64(len(libs_lib_esnext_error_d_ts))}, &fileInfo{name: "lib.esnext.full.d.ts", size: int64(len(libs_lib_esnext_full_d_ts))}, &fileInfo{name: "lib.esnext.intl.d.ts", size: int64(len(libs_lib_esnext_intl_d_ts))}, + &fileInfo{name: "lib.esnext.iterator.d.ts", size: int64(len(libs_lib_esnext_iterator_d_ts))}, &fileInfo{name: "lib.esnext.sharedmemory.d.ts", size: int64(len(libs_lib_esnext_sharedmemory_d_ts))}, &fileInfo{name: "lib.esnext.temporal.d.ts", size: int64(len(libs_lib_esnext_temporal_d_ts))}, &fileInfo{name: "lib.esnext.typedarrays.d.ts", size: int64(len(libs_lib_esnext_typedarrays_d_ts))}, diff --git a/tsc/internal/bundled/libs/lib.esnext.d.ts b/tsc/internal/bundled/libs/lib.esnext.d.ts index 044947f4d2aa0..d336210d567ba 100644 --- a/tsc/internal/bundled/libs/lib.esnext.d.ts +++ b/tsc/internal/bundled/libs/lib.esnext.d.ts @@ -25,3 +25,4 @@ and limitations under the License. /// /// /// +/// diff --git a/tsc/internal/bundled/libs/lib.esnext.iterator.d.ts b/tsc/internal/bundled/libs/lib.esnext.iterator.d.ts new file mode 100644 index 0000000000000..c2f6a6df2fd54 --- /dev/null +++ b/tsc/internal/bundled/libs/lib.esnext.iterator.d.ts @@ -0,0 +1,116 @@ +/*! ***************************************************************************** +Copyright (c) Microsoft Corporation. All rights reserved. +Licensed under the Apache License, Version 2.0 (the "License"); you may not use +this file except in compliance with the License. You may obtain a copy of the +License at http://www.apache.org/licenses/LICENSE-2.0 + +THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED +WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, +MERCHANTABILITY OR NON-INFRINGEMENT. + +See the Apache Version 2.0 License for specific language governing permissions +and limitations under the License. +***************************************************************************** */ + + +/// + +export {}; + +interface IteratorZipShortestOptions { + /** + * Stops when any input is exhausted. + */ + mode?: "shortest"; +} + +interface IteratorZipLongestOptions { + /** + * Continues until every input is exhausted. + */ + mode: "longest"; + + /** + * Values used when an input is exhausted before the others. + */ + padding?: T; +} + +interface IteratorZipStrictOptions { + /** + * Requires every input to yield the same number of values. + */ + mode: "strict"; +} + +type IteratorZipOptions = IteratorZipShortestOptions | IteratorZipLongestOptions | IteratorZipStrictOptions; + +type IteratorInput = Iterable | Iterator; + +type IteratorYield> = + T extends Iterable ? U : + T extends Iterator ? U : + never; + +type IteratorZipResult[]> = { + -readonly [K in keyof T]: IteratorYield; +}; + +type IteratorZipKeyedResult }> = { + -readonly [K in keyof T]: IteratorYield; +}; + +declare global { + interface IteratorObject { + /** + * Creates an iterator whose values are arrays containing successive values from this iterator. + * @param chunkSize The maximum number of values in each array. + */ + chunks(chunkSize: number): IteratorObject; + + /** + * Creates a string by concatenating the values of this iterator, separated by the specified separator. + * `null` and `undefined` values contribute an empty string. + * @param separator A string used to separate values. If omitted, a comma is used. + */ + join(separator?: string): string; + + /** + * Determines whether this iterator yields the specified value using SameValueZero comparison. + * @param searchElement The value to locate. + * @param skippedElements The number of values to skip before searching. + */ + includes(searchElement: T, skippedElements?: number): boolean; + } + + interface IteratorConstructor { + /** + * Creates an iterator whose values are arrays containing values yielded at the same position by each input iterator or iterable. + * @param iterables An iterable of iterators or iterables to zip. + * @param options Controls how differing input lengths are handled. + */ + zip(iterables: readonly [], options?: IteratorZipOptions>): IteratorObject; + + /** + * Creates an iterator whose values are arrays containing values yielded at the same position by each input iterator or iterable. + * @param iterables An iterable of iterators or iterables to zip. + * @param options Controls how differing input lengths are handled. + */ + zip[] | []>(iterables: T, options?: IteratorZipOptions>>>): IteratorObject, undefined, unknown>; + + /** + * Creates an iterator whose values are arrays containing values yielded at the same position by each input iterator or iterable. + * @param iterables An iterable of iterators or iterables to zip. + * @param options Controls how differing input lengths are handled. + */ + zip>(iterables: Iterable, options?: IteratorZipOptions>>>): IteratorObject[], undefined, unknown>; + + /** + * Creates an iterator whose values are objects containing values yielded at the same position by each iterator or iterable in the input object. + * @param iterables An object whose enumerable own properties contain iterators or iterables to zip. + * @param options Controls how differing input lengths are handled. + */ + zipKeyed }>(iterables: T, options?: IteratorZipOptions>>>): IteratorObject, undefined, unknown>; + } +} diff --git a/tsc/internal/bundled/libs_generated.go b/tsc/internal/bundled/libs_generated.go index 6750307190f5b..49253b24f900c 100644 --- a/tsc/internal/bundled/libs_generated.go +++ b/tsc/internal/bundled/libs_generated.go @@ -105,6 +105,7 @@ var LibNames = []string{ "lib.esnext.error.d.ts", "lib.esnext.full.d.ts", "lib.esnext.intl.d.ts", + "lib.esnext.iterator.d.ts", "lib.esnext.sharedmemory.d.ts", "lib.esnext.temporal.d.ts", "lib.esnext.typedarrays.d.ts", diff --git a/tsc/internal/compiler/program_test.go b/tsc/internal/compiler/program_test.go index 0b91d2ce073e0..615aead0b24ff 100644 --- a/tsc/internal/compiler/program_test.go +++ b/tsc/internal/compiler/program_test.go @@ -111,6 +111,7 @@ var esnextLibs = []string{ "lib.es2025.iterator.d.ts", "lib.es2025.promise.d.ts", "lib.es2025.regexp.d.ts", + "lib.esnext.iterator.d.ts", "lib.esnext.array.d.ts", "lib.esnext.collection.d.ts", "lib.esnext.date.d.ts", diff --git a/tsc/internal/tsoptions/enummaps.go b/tsc/internal/tsoptions/enummaps.go index 3bf67a8640675..2f2982f270182 100644 --- a/tsc/internal/tsoptions/enummaps.go +++ b/tsc/internal/tsoptions/enummaps.go @@ -106,9 +106,9 @@ var LibMap = collections.NewOrderedMapFromList([]collections.MapEntry[string, an {Key: "esnext.regexp", Value: "lib.es2024.regexp.d.ts"}, {Key: "esnext.string", Value: "lib.es2024.string.d.ts"}, {Key: "esnext.float16", Value: "lib.es2025.float16.d.ts"}, - {Key: "esnext.iterator", Value: "lib.es2025.iterator.d.ts"}, {Key: "esnext.promise", Value: "lib.es2025.promise.d.ts"}, // ESNext By-feature options + {Key: "esnext.iterator", Value: "lib.esnext.iterator.d.ts"}, {Key: "esnext.array", Value: "lib.esnext.array.d.ts"}, {Key: "esnext.collection", Value: "lib.esnext.collection.d.ts"}, {Key: "esnext.date", Value: "lib.esnext.date.d.ts"}, diff --git a/tsc/testdata/baselines/reference/compiler/builtinIterator.symbols b/tsc/testdata/baselines/reference/compiler/builtinIterator.symbols index 8cca78ea45700..d85974669fc57 100644 --- a/tsc/testdata/baselines/reference/compiler/builtinIterator.symbols +++ b/tsc/testdata/baselines/reference/compiler/builtinIterator.symbols @@ -184,7 +184,7 @@ const iter1 = Iterator.from(g1); declare const iter2: IteratorObject; >iter2 : Symbol(iter2, Decl(builtinIterator.ts, 71, 13)) ->IteratorObject : Symbol(IteratorObject, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.esnext.disposable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>IteratorObject : Symbol(IteratorObject, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.esnext.disposable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) const iter3 = iter2.flatMap(() => g1); >iter3 : Symbol(iter3, Decl(builtinIterator.ts, 72, 5)) diff --git a/tsc/testdata/baselines/reference/compiler/builtinIterator.types b/tsc/testdata/baselines/reference/compiler/builtinIterator.types index 36094697ac1ef..30a71077c28cf 100644 --- a/tsc/testdata/baselines/reference/compiler/builtinIterator.types +++ b/tsc/testdata/baselines/reference/compiler/builtinIterator.types @@ -4,9 +4,9 @@ const iterator = Iterator.from([0, 1, 2]); >iterator : IteratorObject >Iterator.from([0, 1, 2]) : IteratorObject ->Iterator.from : (value: Iterator | Iterable) => IteratorObject +>Iterator.from : (value: Iterable | Iterator) => IteratorObject >Iterator : IteratorConstructor ->from : (value: Iterator | Iterable) => IteratorObject +>from : (value: Iterable | Iterator) => IteratorObject >[0, 1, 2] : number[] >0 : 0 >1 : 1 @@ -52,9 +52,9 @@ const zero = iterator.filter(isZero); const iteratorFromBare = Iterator.from({ >iteratorFromBare : IteratorObject >Iterator.from({ next() { return { done: Math.random() < .5, value: "a string", }; },}) : IteratorObject ->Iterator.from : (value: Iterator | Iterable) => IteratorObject +>Iterator.from : (value: Iterable | Iterator) => IteratorObject >Iterator : IteratorConstructor ->from : (value: Iterator | Iterable) => IteratorObject +>from : (value: Iterable | Iterator) => IteratorObject >{ next() { return { done: Math.random() < .5, value: "a string", }; },} : { next(): { done: boolean; value: string; }; } next() { @@ -244,9 +244,9 @@ declare const g1: Generator; const iter1 = Iterator.from(g1); >iter1 : IteratorObject >Iterator.from(g1) : IteratorObject ->Iterator.from : (value: Iterator | Iterable) => IteratorObject +>Iterator.from : (value: Iterable | Iterator) => IteratorObject >Iterator : IteratorConstructor ->from : (value: Iterator | Iterable) => IteratorObject +>from : (value: Iterable | Iterator) => IteratorObject >g1 : Generator declare const iter2: IteratorObject; diff --git a/tsc/testdata/baselines/reference/compiler/iteratorChunks.js b/tsc/testdata/baselines/reference/compiler/iteratorChunks.js new file mode 100644 index 0000000000000..7a8ed2e291199 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorChunks.js @@ -0,0 +1,14 @@ +//// [tests/cases/compiler/iteratorChunks.ts] //// + +//// [iteratorChunks.ts] +const chunks: number[][] = Iterator.from([1, 2, 3]).chunks(2).toArray(); + +// @ts-expect-error chunk size must be a number +Iterator.from([1, 2, 3]).chunks("2"); + + +//// [iteratorChunks.js] +"use strict"; +const chunks = Iterator.from([1, 2, 3]).chunks(2).toArray(); +// @ts-expect-error chunk size must be a number +Iterator.from([1, 2, 3]).chunks("2"); diff --git a/tsc/testdata/baselines/reference/compiler/iteratorChunks.symbols b/tsc/testdata/baselines/reference/compiler/iteratorChunks.symbols new file mode 100644 index 0000000000000..4ba63bd206cc4 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorChunks.symbols @@ -0,0 +1,21 @@ +//// [tests/cases/compiler/iteratorChunks.ts] //// + +=== iteratorChunks.ts === +const chunks: number[][] = Iterator.from([1, 2, 3]).chunks(2).toArray(); +>chunks : Symbol(chunks, Decl(iteratorChunks.ts, 0, 5)) +>Iterator.from([1, 2, 3]).chunks(2).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.from([1, 2, 3]).chunks : Symbol(IteratorObject.chunks, Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator.from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) +>chunks : Symbol(IteratorObject.chunks, Decl(lib.esnext.iterator.d.ts, --, --)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +// @ts-expect-error chunk size must be a number +Iterator.from([1, 2, 3]).chunks("2"); +>Iterator.from([1, 2, 3]).chunks : Symbol(IteratorObject.chunks, Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator.from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) +>chunks : Symbol(IteratorObject.chunks, Decl(lib.esnext.iterator.d.ts, --, --)) + diff --git a/tsc/testdata/baselines/reference/compiler/iteratorChunks.types b/tsc/testdata/baselines/reference/compiler/iteratorChunks.types new file mode 100644 index 0000000000000..7be86f8bdfe48 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorChunks.types @@ -0,0 +1,36 @@ +//// [tests/cases/compiler/iteratorChunks.ts] //// + +=== iteratorChunks.ts === +const chunks: number[][] = Iterator.from([1, 2, 3]).chunks(2).toArray(); +>chunks : number[][] +>Iterator.from([1, 2, 3]).chunks(2).toArray() : number[][] +>Iterator.from([1, 2, 3]).chunks(2).toArray : () => number[][] +>Iterator.from([1, 2, 3]).chunks(2) : IteratorObject +>Iterator.from([1, 2, 3]).chunks : (chunkSize: number) => IteratorObject +>Iterator.from([1, 2, 3]) : IteratorObject +>Iterator.from : (value: Iterable | Iterator) => IteratorObject +>Iterator : IteratorConstructor +>from : (value: Iterable | Iterator) => IteratorObject +>[1, 2, 3] : number[] +>1 : 1 +>2 : 2 +>3 : 3 +>chunks : (chunkSize: number) => IteratorObject +>2 : 2 +>toArray : () => number[][] + +// @ts-expect-error chunk size must be a number +Iterator.from([1, 2, 3]).chunks("2"); +>Iterator.from([1, 2, 3]).chunks("2") : IteratorObject +>Iterator.from([1, 2, 3]).chunks : (chunkSize: number) => IteratorObject +>Iterator.from([1, 2, 3]) : IteratorObject +>Iterator.from : (value: Iterable | Iterator) => IteratorObject +>Iterator : IteratorConstructor +>from : (value: Iterable | Iterator) => IteratorObject +>[1, 2, 3] : number[] +>1 : 1 +>2 : 2 +>3 : 3 +>chunks : (chunkSize: number) => IteratorObject +>"2" : "2" + diff --git a/tsc/testdata/baselines/reference/compiler/iteratorIncludes.js b/tsc/testdata/baselines/reference/compiler/iteratorIncludes.js new file mode 100644 index 0000000000000..1ea356fb40321 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorIncludes.js @@ -0,0 +1,21 @@ +//// [tests/cases/compiler/iteratorIncludes.ts] //// + +//// [iteratorIncludes.ts] +const includes: boolean = Iterator.from([1, 2, 3]).includes(2); +const includesAfterSkipping: boolean = Iterator.from([1, 2, 3]).includes(2, 1); + +// @ts-expect-error the searched value must match the iterator value +Iterator.from([1, 2, 3]).includes("1"); + +// @ts-expect-error skipped elements must be a number +Iterator.from([1, 2, 3]).includes(2, "1"); + + +//// [iteratorIncludes.js] +"use strict"; +const includes = Iterator.from([1, 2, 3]).includes(2); +const includesAfterSkipping = Iterator.from([1, 2, 3]).includes(2, 1); +// @ts-expect-error the searched value must match the iterator value +Iterator.from([1, 2, 3]).includes("1"); +// @ts-expect-error skipped elements must be a number +Iterator.from([1, 2, 3]).includes(2, "1"); diff --git a/tsc/testdata/baselines/reference/compiler/iteratorIncludes.symbols b/tsc/testdata/baselines/reference/compiler/iteratorIncludes.symbols new file mode 100644 index 0000000000000..0b1fc3aa3aa5d --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorIncludes.symbols @@ -0,0 +1,35 @@ +//// [tests/cases/compiler/iteratorIncludes.ts] //// + +=== iteratorIncludes.ts === +const includes: boolean = Iterator.from([1, 2, 3]).includes(2); +>includes : Symbol(includes, Decl(iteratorIncludes.ts, 0, 5)) +>Iterator.from([1, 2, 3]).includes : Symbol(IteratorObject.includes, Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator.from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) +>includes : Symbol(IteratorObject.includes, Decl(lib.esnext.iterator.d.ts, --, --)) + +const includesAfterSkipping: boolean = Iterator.from([1, 2, 3]).includes(2, 1); +>includesAfterSkipping : Symbol(includesAfterSkipping, Decl(iteratorIncludes.ts, 1, 5)) +>Iterator.from([1, 2, 3]).includes : Symbol(IteratorObject.includes, Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator.from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) +>includes : Symbol(IteratorObject.includes, Decl(lib.esnext.iterator.d.ts, --, --)) + +// @ts-expect-error the searched value must match the iterator value +Iterator.from([1, 2, 3]).includes("1"); +>Iterator.from([1, 2, 3]).includes : Symbol(IteratorObject.includes, Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator.from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) +>includes : Symbol(IteratorObject.includes, Decl(lib.esnext.iterator.d.ts, --, --)) + +// @ts-expect-error skipped elements must be a number +Iterator.from([1, 2, 3]).includes(2, "1"); +>Iterator.from([1, 2, 3]).includes : Symbol(IteratorObject.includes, Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator.from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) +>includes : Symbol(IteratorObject.includes, Decl(lib.esnext.iterator.d.ts, --, --)) + diff --git a/tsc/testdata/baselines/reference/compiler/iteratorIncludes.types b/tsc/testdata/baselines/reference/compiler/iteratorIncludes.types new file mode 100644 index 0000000000000..66bfdd1da6992 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorIncludes.types @@ -0,0 +1,65 @@ +//// [tests/cases/compiler/iteratorIncludes.ts] //// + +=== iteratorIncludes.ts === +const includes: boolean = Iterator.from([1, 2, 3]).includes(2); +>includes : boolean +>Iterator.from([1, 2, 3]).includes(2) : boolean +>Iterator.from([1, 2, 3]).includes : (searchElement: number, skippedElements?: number) => boolean +>Iterator.from([1, 2, 3]) : IteratorObject +>Iterator.from : (value: Iterable | Iterator) => IteratorObject +>Iterator : IteratorConstructor +>from : (value: Iterable | Iterator) => IteratorObject +>[1, 2, 3] : number[] +>1 : 1 +>2 : 2 +>3 : 3 +>includes : (searchElement: number, skippedElements?: number) => boolean +>2 : 2 + +const includesAfterSkipping: boolean = Iterator.from([1, 2, 3]).includes(2, 1); +>includesAfterSkipping : boolean +>Iterator.from([1, 2, 3]).includes(2, 1) : boolean +>Iterator.from([1, 2, 3]).includes : (searchElement: number, skippedElements?: number) => boolean +>Iterator.from([1, 2, 3]) : IteratorObject +>Iterator.from : (value: Iterable | Iterator) => IteratorObject +>Iterator : IteratorConstructor +>from : (value: Iterable | Iterator) => IteratorObject +>[1, 2, 3] : number[] +>1 : 1 +>2 : 2 +>3 : 3 +>includes : (searchElement: number, skippedElements?: number) => boolean +>2 : 2 +>1 : 1 + +// @ts-expect-error the searched value must match the iterator value +Iterator.from([1, 2, 3]).includes("1"); +>Iterator.from([1, 2, 3]).includes("1") : boolean +>Iterator.from([1, 2, 3]).includes : (searchElement: number, skippedElements?: number) => boolean +>Iterator.from([1, 2, 3]) : IteratorObject +>Iterator.from : (value: Iterable | Iterator) => IteratorObject +>Iterator : IteratorConstructor +>from : (value: Iterable | Iterator) => IteratorObject +>[1, 2, 3] : number[] +>1 : 1 +>2 : 2 +>3 : 3 +>includes : (searchElement: number, skippedElements?: number) => boolean +>"1" : "1" + +// @ts-expect-error skipped elements must be a number +Iterator.from([1, 2, 3]).includes(2, "1"); +>Iterator.from([1, 2, 3]).includes(2, "1") : boolean +>Iterator.from([1, 2, 3]).includes : (searchElement: number, skippedElements?: number) => boolean +>Iterator.from([1, 2, 3]) : IteratorObject +>Iterator.from : (value: Iterable | Iterator) => IteratorObject +>Iterator : IteratorConstructor +>from : (value: Iterable | Iterator) => IteratorObject +>[1, 2, 3] : number[] +>1 : 1 +>2 : 2 +>3 : 3 +>includes : (searchElement: number, skippedElements?: number) => boolean +>2 : 2 +>"1" : "1" + diff --git a/tsc/testdata/baselines/reference/compiler/iteratorJoin.js b/tsc/testdata/baselines/reference/compiler/iteratorJoin.js new file mode 100644 index 0000000000000..2d8983a916905 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorJoin.js @@ -0,0 +1,16 @@ +//// [tests/cases/compiler/iteratorJoin.ts] //// + +//// [iteratorJoin.ts] +const joined: string = Iterator.from([1, 2, 3]).join("-"); +const joinedWithDefaultSeparator: string = Iterator.from([1, 2, 3]).join(); + +// @ts-expect-error separator must be a string +Iterator.from([1, 2, 3]).join(0); + + +//// [iteratorJoin.js] +"use strict"; +const joined = Iterator.from([1, 2, 3]).join("-"); +const joinedWithDefaultSeparator = Iterator.from([1, 2, 3]).join(); +// @ts-expect-error separator must be a string +Iterator.from([1, 2, 3]).join(0); diff --git a/tsc/testdata/baselines/reference/compiler/iteratorJoin.symbols b/tsc/testdata/baselines/reference/compiler/iteratorJoin.symbols new file mode 100644 index 0000000000000..d004fb3482b46 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorJoin.symbols @@ -0,0 +1,27 @@ +//// [tests/cases/compiler/iteratorJoin.ts] //// + +=== iteratorJoin.ts === +const joined: string = Iterator.from([1, 2, 3]).join("-"); +>joined : Symbol(joined, Decl(iteratorJoin.ts, 0, 5)) +>Iterator.from([1, 2, 3]).join : Symbol(IteratorObject.join, Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator.from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) +>join : Symbol(IteratorObject.join, Decl(lib.esnext.iterator.d.ts, --, --)) + +const joinedWithDefaultSeparator: string = Iterator.from([1, 2, 3]).join(); +>joinedWithDefaultSeparator : Symbol(joinedWithDefaultSeparator, Decl(iteratorJoin.ts, 1, 5)) +>Iterator.from([1, 2, 3]).join : Symbol(IteratorObject.join, Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator.from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) +>join : Symbol(IteratorObject.join, Decl(lib.esnext.iterator.d.ts, --, --)) + +// @ts-expect-error separator must be a string +Iterator.from([1, 2, 3]).join(0); +>Iterator.from([1, 2, 3]).join : Symbol(IteratorObject.join, Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator.from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) +>join : Symbol(IteratorObject.join, Decl(lib.esnext.iterator.d.ts, --, --)) + diff --git a/tsc/testdata/baselines/reference/compiler/iteratorJoin.types b/tsc/testdata/baselines/reference/compiler/iteratorJoin.types new file mode 100644 index 0000000000000..55ed9784d2056 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorJoin.types @@ -0,0 +1,47 @@ +//// [tests/cases/compiler/iteratorJoin.ts] //// + +=== iteratorJoin.ts === +const joined: string = Iterator.from([1, 2, 3]).join("-"); +>joined : string +>Iterator.from([1, 2, 3]).join("-") : string +>Iterator.from([1, 2, 3]).join : (separator?: string) => string +>Iterator.from([1, 2, 3]) : IteratorObject +>Iterator.from : (value: Iterable | Iterator) => IteratorObject +>Iterator : IteratorConstructor +>from : (value: Iterable | Iterator) => IteratorObject +>[1, 2, 3] : number[] +>1 : 1 +>2 : 2 +>3 : 3 +>join : (separator?: string) => string +>"-" : "-" + +const joinedWithDefaultSeparator: string = Iterator.from([1, 2, 3]).join(); +>joinedWithDefaultSeparator : string +>Iterator.from([1, 2, 3]).join() : string +>Iterator.from([1, 2, 3]).join : (separator?: string) => string +>Iterator.from([1, 2, 3]) : IteratorObject +>Iterator.from : (value: Iterable | Iterator) => IteratorObject +>Iterator : IteratorConstructor +>from : (value: Iterable | Iterator) => IteratorObject +>[1, 2, 3] : number[] +>1 : 1 +>2 : 2 +>3 : 3 +>join : (separator?: string) => string + +// @ts-expect-error separator must be a string +Iterator.from([1, 2, 3]).join(0); +>Iterator.from([1, 2, 3]).join(0) : string +>Iterator.from([1, 2, 3]).join : (separator?: string) => string +>Iterator.from([1, 2, 3]) : IteratorObject +>Iterator.from : (value: Iterable | Iterator) => IteratorObject +>Iterator : IteratorConstructor +>from : (value: Iterable | Iterator) => IteratorObject +>[1, 2, 3] : number[] +>1 : 1 +>2 : 2 +>3 : 3 +>join : (separator?: string) => string +>0 : 0 + diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip.js b/tsc/testdata/baselines/reference/compiler/iteratorZip.js new file mode 100644 index 0000000000000..5148a43bc92c2 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorZip.js @@ -0,0 +1,91 @@ +//// [tests/cases/compiler/iteratorZip.ts] //// + +//// [iteratorZip.ts] +declare const key: unique symbol; + +const tuples: [number, string][] = Iterator.zip([ + [1, 2], + new Set(["a", "b"]), +] as const).toArray(); + +tuples[0][0] = 2; + +Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }); +Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }); +Iterator.zip([[1], ["a"]] as const, { mode: "strict" }); + +const empty: never[] = Iterator.zip([]).toArray(); + +declare const iterables: Iterable>; +const arrays: number[][] = Iterator.zip(iterables).toArray(); + +const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ + a: [1, 2], + b: new Set(["a", "b"]), + [key]: [true, false], +} as const).toArray(); + +objects[0].a = 2; + +Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { + mode: "longest", + padding: { b: "a" }, +}); + +interface Inputs { + a: Iterable; + b: Iterator; +} + +declare const inputs: Inputs; +const rows: { a: number; b: string; }[] = Iterator.zipKeyed(inputs).toArray(); + +// @ts-expect-error invalid mode +Iterator.zip([[1]], { mode: "invalid" }); + +// @ts-expect-error padding values must match the input element types +Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }); + +// @ts-expect-error padding is only used in longest mode +Iterator.zip([[1]], { mode: "shortest", padding: [1] }); + +// @ts-expect-error the input must be iterable +Iterator.zip(0); + +// @ts-expect-error each keyed value must be iterable +Iterator.zipKeyed({ a: 0 }); + + +//// [iteratorZip.js] +"use strict"; +const tuples = Iterator.zip([ + [1, 2], + new Set(["a", "b"]), +]).toArray(); +tuples[0][0] = 2; +Iterator.zip([[1], ["a"]], { mode: "shortest" }); +Iterator.zip([[1], ["a"]], { mode: "longest", padding: [1] }); +Iterator.zip([[1], ["a"]], { mode: "strict" }); +const empty = Iterator.zip([]).toArray(); +const arrays = Iterator.zip(iterables).toArray(); +const objects = Iterator.zipKeyed({ + a: [1, 2], + b: new Set(["a", "b"]), + [key]: [true, false], +}).toArray(); +objects[0].a = 2; +Iterator.zipKeyed({ a: [1], b: ["a"] }, { + mode: "longest", + padding: { b: "a" }, +}); +const rows = Iterator.zipKeyed(inputs).toArray(); +// @ts-expect-error invalid mode +Iterator.zip([[1]], { mode: "invalid" }); +// @ts-expect-error padding values must match the input element types +Iterator.zip([[1], ["a"]], { mode: "longest", padding: [true] }); +// @ts-expect-error padding is only used in longest mode +Iterator.zip([[1]], { mode: "shortest", padding: [1] }); +// @ts-expect-error the input must be iterable +Iterator.zip(0); +// @ts-expect-error each keyed value must be iterable +Iterator.zipKeyed({ a: 0 }); diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip.symbols b/tsc/testdata/baselines/reference/compiler/iteratorZip.symbols new file mode 100644 index 0000000000000..8ac41ad65154a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorZip.symbols @@ -0,0 +1,181 @@ +//// [tests/cases/compiler/iteratorZip.ts] //// + +=== iteratorZip.ts === +declare const key: unique symbol; +>key : Symbol(key, Decl(iteratorZip.ts, 0, 13)) + +const tuples: [number, string][] = Iterator.zip([ +>tuples : Symbol(tuples, Decl(iteratorZip.ts, 2, 5)) +>Iterator.zip([ [1, 2], new Set(["a", "b"]),] as const).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) + + [1, 2], + new Set(["a", "b"]), +>Set : Symbol(Set, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) + +] as const).toArray(); +>const : Symbol(const) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +tuples[0][0] = 2; +>tuples : Symbol(tuples, Decl(iteratorZip.ts, 2, 5)) +>0 : Symbol(0) + +Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>const : Symbol(const) +>mode : Symbol(mode, Decl(iteratorZip.ts, 9, 37)) + +Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>const : Symbol(const) +>mode : Symbol(mode, Decl(iteratorZip.ts, 10, 37)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 10, 54)) + +Iterator.zip([[1], ["a"]] as const, { mode: "strict" }); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>const : Symbol(const) +>mode : Symbol(mode, Decl(iteratorZip.ts, 11, 37)) + +const empty: never[] = Iterator.zip([]).toArray(); +>empty : Symbol(empty, Decl(iteratorZip.ts, 13, 5)) +>Iterator.zip([]).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const iterables: Iterable>; +>iterables : Symbol(iterables, Decl(iteratorZip.ts, 15, 13)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + +const arrays: number[][] = Iterator.zip(iterables).toArray(); +>arrays : Symbol(arrays, Decl(iteratorZip.ts, 16, 5)) +>Iterator.zip(iterables).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>iterables : Symbol(iterables, Decl(iteratorZip.ts, 15, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ +>objects : Symbol(objects, Decl(iteratorZip.ts, 18, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 18, 16)) +>b : Symbol(b, Decl(iteratorZip.ts, 18, 27)) +>[key] : Symbol([key], Decl(iteratorZip.ts, 18, 38)) +>key : Symbol(key, Decl(iteratorZip.ts, 0, 13)) +>Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --)) + + a: [1, 2], +>a : Symbol(a, Decl(iteratorZip.ts, 18, 80)) + + b: new Set(["a", "b"]), +>b : Symbol(b, Decl(iteratorZip.ts, 19, 14)) +>Set : Symbol(Set, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) + + [key]: [true, false], +>[key] : Symbol([key], Decl(iteratorZip.ts, 20, 27)) +>key : Symbol(key, Decl(iteratorZip.ts, 0, 13)) + +} as const).toArray(); +>const : Symbol(const) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +objects[0].a = 2; +>objects[0].a : Symbol(a, Decl(iteratorZip.ts, 18, 16)) +>objects : Symbol(objects, Decl(iteratorZip.ts, 18, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 18, 16)) + +Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 26, 19)) +>b : Symbol(b, Decl(iteratorZip.ts, 26, 27)) +>const : Symbol(const) + + mode: "longest", +>mode : Symbol(mode, Decl(iteratorZip.ts, 26, 50)) + + padding: { b: "a" }, +>padding : Symbol(padding, Decl(iteratorZip.ts, 27, 20)) +>b : Symbol(b, Decl(iteratorZip.ts, 28, 14)) + +}); + +interface Inputs { +>Inputs : Symbol(Inputs, Decl(iteratorZip.ts, 29, 3)) + + a: Iterable; +>a : Symbol(Inputs.a, Decl(iteratorZip.ts, 31, 18)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + + b: Iterator; +>b : Symbol(Inputs.b, Decl(iteratorZip.ts, 32, 24)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +} + +declare const inputs: Inputs; +>inputs : Symbol(inputs, Decl(iteratorZip.ts, 36, 13)) +>Inputs : Symbol(Inputs, Decl(iteratorZip.ts, 29, 3)) + +const rows: { a: number; b: string; }[] = Iterator.zipKeyed(inputs).toArray(); +>rows : Symbol(rows, Decl(iteratorZip.ts, 37, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 37, 13)) +>b : Symbol(b, Decl(iteratorZip.ts, 37, 24)) +>Iterator.zipKeyed(inputs).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --)) +>inputs : Symbol(inputs, Decl(iteratorZip.ts, 36, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +// @ts-expect-error invalid mode +Iterator.zip([[1]], { mode: "invalid" }); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 40, 21)) + +// @ts-expect-error padding values must match the input element types +Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>const : Symbol(const) +>mode : Symbol(mode, Decl(iteratorZip.ts, 43, 37)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 43, 54)) + +// @ts-expect-error padding is only used in longest mode +Iterator.zip([[1]], { mode: "shortest", padding: [1] }); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 46, 21)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 46, 39)) + +// @ts-expect-error the input must be iterable +Iterator.zip(0); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) + +// @ts-expect-error each keyed value must be iterable +Iterator.zipKeyed({ a: 0 }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 52, 19)) + diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip.types b/tsc/testdata/baselines/reference/compiler/iteratorZip.types new file mode 100644 index 0000000000000..0ee4392d2b4ef --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorZip.types @@ -0,0 +1,279 @@ +//// [tests/cases/compiler/iteratorZip.ts] //// + +=== iteratorZip.ts === +declare const key: unique symbol; +>key : unique symbol + +const tuples: [number, string][] = Iterator.zip([ +>tuples : [number, string][] +>Iterator.zip([ [1, 2], new Set(["a", "b"]),] as const).toArray() : [1 | 2, string][] +>Iterator.zip([ [1, 2], new Set(["a", "b"]),] as const).toArray : () => [1 | 2, string][] +>Iterator.zip([ [1, 2], new Set(["a", "b"]),] as const) : IteratorObject<[1 | 2, string], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +>[ [1, 2], new Set(["a", "b"]),] as const : [readonly [1, 2], Set] +>[ [1, 2], new Set(["a", "b"]),] : [readonly [1, 2], Set] + + [1, 2], +>[1, 2] : readonly [1, 2] +>1 : 1 +>2 : 2 + + new Set(["a", "b"]), +>new Set(["a", "b"]) : Set +>Set : SetConstructor +>["a", "b"] : string[] +>"a" : "a" +>"b" : "b" + +] as const).toArray(); +>toArray : () => [1 | 2, string][] + +tuples[0][0] = 2; +>tuples[0][0] = 2 : 2 +>tuples[0][0] : number +>tuples[0] : [number, string] +>tuples : [number, string][] +>0 : 0 +>0 : 0 +>2 : 2 + +Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }); +>Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }) : IteratorObject<[1, "a"], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +>[[1], ["a"]] as const : [readonly [1], readonly ["a"]] +>[[1], ["a"]] : [readonly [1], readonly ["a"]] +>[1] : readonly [1] +>1 : 1 +>["a"] : readonly ["a"] +>"a" : "a" +>{ mode: "shortest" } : { mode: "shortest"; } +>mode : "shortest" +>"shortest" : "shortest" + +Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }); +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }) : IteratorObject<[1, "a"], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +>[[1], ["a"]] as const : [readonly [1], readonly ["a"]] +>[[1], ["a"]] : [readonly [1], readonly ["a"]] +>[1] : readonly [1] +>1 : 1 +>["a"] : readonly ["a"] +>"a" : "a" +>{ mode: "longest", padding: [1] } : { mode: "longest"; padding: [1]; } +>mode : "longest" +>"longest" : "longest" +>padding : [1] +>[1] : [1] +>1 : 1 + +Iterator.zip([[1], ["a"]] as const, { mode: "strict" }); +>Iterator.zip([[1], ["a"]] as const, { mode: "strict" }) : IteratorObject<[1, "a"], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +>[[1], ["a"]] as const : [readonly [1], readonly ["a"]] +>[[1], ["a"]] : [readonly [1], readonly ["a"]] +>[1] : readonly [1] +>1 : 1 +>["a"] : readonly ["a"] +>"a" : "a" +>{ mode: "strict" } : { mode: "strict"; } +>mode : "strict" +>"strict" : "strict" + +const empty: never[] = Iterator.zip([]).toArray(); +>empty : never[] +>Iterator.zip([]).toArray() : never[] +>Iterator.zip([]).toArray : () => never[] +>Iterator.zip([]) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +>[] : [] +>toArray : () => never[] + +declare const iterables: Iterable>; +>iterables : Iterable> + +const arrays: number[][] = Iterator.zip(iterables).toArray(); +>arrays : number[][] +>Iterator.zip(iterables).toArray() : number[][] +>Iterator.zip(iterables).toArray : () => number[][] +>Iterator.zip(iterables) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +>iterables : Iterable> +>toArray : () => number[][] + +const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ +>objects : { a: number; b: string; [key]: boolean; }[] +>a : number +>b : string +>[key] : boolean +>key : unique symbol +>Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const).toArray() : { a: 1 | 2; b: string; [key]: boolean; }[] +>Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const).toArray : () => { a: 1 | 2; b: string; [key]: boolean; }[] +>Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const) : IteratorObject<{ a: 1 | 2; b: string; [key]: boolean; }, undefined, unknown> +>Iterator.zipKeyed : | Iterator; }>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined) => IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown> +>Iterator : IteratorConstructor +>zipKeyed : | Iterator; }>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined) => IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown> +>{ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const : { readonly a: readonly [1, 2]; readonly b: Set; readonly [key]: readonly [true, false]; } +>{ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} : { readonly a: readonly [1, 2]; readonly b: Set; readonly [key]: readonly [true, false]; } + + a: [1, 2], +>a : readonly [1, 2] +>[1, 2] : readonly [1, 2] +>1 : 1 +>2 : 2 + + b: new Set(["a", "b"]), +>b : Set +>new Set(["a", "b"]) : Set +>Set : SetConstructor +>["a", "b"] : string[] +>"a" : "a" +>"b" : "b" + + [key]: [true, false], +>[key] : readonly [true, false] +>key : unique symbol +>[true, false] : readonly [true, false] +>true : true +>false : false + +} as const).toArray(); +>toArray : () => { a: 1 | 2; b: string; [key]: boolean; }[] + +objects[0].a = 2; +>objects[0].a = 2 : 2 +>objects[0].a : number +>objects[0] : { a: number; b: string; [key]: boolean; } +>objects : { a: number; b: string; [key]: boolean; }[] +>0 : 0 +>a : number +>2 : 2 + +Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}) : IteratorObject<{ a: 1; b: "a"; }, undefined, unknown> +>Iterator.zipKeyed : | Iterator; }>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined) => IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown> +>Iterator : IteratorConstructor +>zipKeyed : | Iterator; }>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined) => IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown> +>{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } +>{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } +>a : readonly [1] +>[1] : readonly [1] +>1 : 1 +>b : readonly ["a"] +>["a"] : readonly ["a"] +>"a" : "a" +>{ mode: "longest", padding: { b: "a" },} : { mode: "longest"; padding: { b: "a"; }; } + + mode: "longest", +>mode : "longest" +>"longest" : "longest" + + padding: { b: "a" }, +>padding : { b: "a"; } +>{ b: "a" } : { b: "a"; } +>b : "a" +>"a" : "a" + +}); + +interface Inputs { + a: Iterable; +>a : Iterable + + b: Iterator; +>b : Iterator +} + +declare const inputs: Inputs; +>inputs : Inputs + +const rows: { a: number; b: string; }[] = Iterator.zipKeyed(inputs).toArray(); +>rows : { a: number; b: string; }[] +>a : number +>b : string +>Iterator.zipKeyed(inputs).toArray() : { a: number; b: string; }[] +>Iterator.zipKeyed(inputs).toArray : () => { a: number; b: string; }[] +>Iterator.zipKeyed(inputs) : IteratorObject<{ a: number; b: string; }, undefined, unknown> +>Iterator.zipKeyed : | Iterator; }>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined) => IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown> +>Iterator : IteratorConstructor +>zipKeyed : | Iterator; }>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined) => IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown> +>inputs : Inputs +>toArray : () => { a: number; b: string; }[] + +// @ts-expect-error invalid mode +Iterator.zip([[1]], { mode: "invalid" }); +>Iterator.zip([[1]], { mode: "invalid" }) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +>[[1]] : [number[]] +>[1] : number[] +>1 : 1 +>{ mode: "invalid" } : { mode: "invalid"; } +>mode : "invalid" +>"invalid" : "invalid" + +// @ts-expect-error padding values must match the input element types +Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }); +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +>[[1], ["a"]] as const : readonly [readonly [1], readonly ["a"]] +>[[1], ["a"]] : readonly [readonly [1], readonly ["a"]] +>[1] : readonly [1] +>1 : 1 +>["a"] : readonly ["a"] +>"a" : "a" +>{ mode: "longest", padding: [true] } : { mode: "longest"; padding: boolean[]; } +>mode : "longest" +>"longest" : "longest" +>padding : boolean[] +>[true] : boolean[] +>true : true + +// @ts-expect-error padding is only used in longest mode +Iterator.zip([[1]], { mode: "shortest", padding: [1] }); +>Iterator.zip([[1]], { mode: "shortest", padding: [1] }) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +>[[1]] : [number[]] +>[1] : number[] +>1 : 1 +>{ mode: "shortest", padding: [1] } : { mode: "shortest"; padding: number[]; } +>mode : "shortest" +>"shortest" : "shortest" +>padding : number[] +>[1] : number[] +>1 : 1 + +// @ts-expect-error the input must be iterable +Iterator.zip(0); +>Iterator.zip(0) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +>0 : 0 + +// @ts-expect-error each keyed value must be iterable +Iterator.zipKeyed({ a: 0 }); +>Iterator.zipKeyed({ a: 0 }) : IteratorObject<{ a: unknown; }, undefined, unknown> +>Iterator.zipKeyed : | Iterator; }>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined) => IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown> +>Iterator : IteratorConstructor +>zipKeyed : | Iterator; }>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined) => IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown> +>{ a: 0 } : { a: number; } +>a : number +>0 : 0 + diff --git a/tsc/testdata/baselines/reference/compiler/libReplacement(libreplacement=true).trace.json b/tsc/testdata/baselines/reference/compiler/libReplacement(libreplacement=true).trace.json index 28065b7104c94..e39c415794c97 100644 --- a/tsc/testdata/baselines/reference/compiler/libReplacement(libreplacement=true).trace.json +++ b/tsc/testdata/baselines/reference/compiler/libReplacement(libreplacement=true).trace.json @@ -1090,6 +1090,19 @@ Searching all ancestor node_modules directories for fallback extensions: JavaScr Directory '/.src/node_modules' does not exist, skipping all lookups in it. Directory '/node_modules' does not exist, skipping all lookups in it. ======== Module name '@typescript/lib-esnext/intl' was not resolved. ======== +======== Resolving module '@typescript/lib-esnext/iterator' from '/.src/__lib_node_modules_lookup_lib.esnext.iterator.d.ts__.ts'. ======== +Module resolution kind is not specified, using 'Bundler'. +Resolving in CJS mode with conditions 'require', 'types'. +File '/.src/package.json' does not exist according to earlier cached lookups. +File '/package.json' does not exist according to earlier cached lookups. +Loading module '@typescript/lib-esnext/iterator' from 'node_modules' folder, target file types: TypeScript, JavaScript, Declaration, JSON. +Searching all ancestor node_modules directories for preferred extensions: TypeScript, Declaration. +Directory '/.src/node_modules' does not exist, skipping all lookups in it. +Directory '/node_modules' does not exist, skipping all lookups in it. +Searching all ancestor node_modules directories for fallback extensions: JavaScript, JSON. +Directory '/.src/node_modules' does not exist, skipping all lookups in it. +Directory '/node_modules' does not exist, skipping all lookups in it. +======== Module name '@typescript/lib-esnext/iterator' was not resolved. ======== ======== Resolving module '@typescript/lib-esnext/sharedmemory' from '/.src/__lib_node_modules_lookup_lib.esnext.sharedmemory.d.ts__.ts'. ======== Module resolution kind is not specified, using 'Bundler'. Resolving in CJS mode with conditions 'require', 'types'. diff --git a/tsc/testdata/baselines/reference/conformance/awaitUsingDeclarationsWithIteratorObject.symbols b/tsc/testdata/baselines/reference/conformance/awaitUsingDeclarationsWithIteratorObject.symbols index 994515eebf247..2d3dc7de54757 100644 --- a/tsc/testdata/baselines/reference/conformance/awaitUsingDeclarationsWithIteratorObject.symbols +++ b/tsc/testdata/baselines/reference/conformance/awaitUsingDeclarationsWithIteratorObject.symbols @@ -7,7 +7,7 @@ declare const i: Iterator; declare const io: IteratorObject; >io : Symbol(io, Decl(awaitUsingDeclarationsWithIteratorObject.ts, 1, 13)) ->IteratorObject : Symbol(IteratorObject, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.esnext.disposable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>IteratorObject : Symbol(IteratorObject, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.esnext.disposable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) declare const g: Generator; >g : Symbol(g, Decl(awaitUsingDeclarationsWithIteratorObject.ts, 2, 13)) diff --git a/tsc/testdata/baselines/reference/conformance/awaitUsingDeclarationsWithIteratorObject.types b/tsc/testdata/baselines/reference/conformance/awaitUsingDeclarationsWithIteratorObject.types index dbc6941c863dd..c0f8f32e550de 100644 --- a/tsc/testdata/baselines/reference/conformance/awaitUsingDeclarationsWithIteratorObject.types +++ b/tsc/testdata/baselines/reference/conformance/awaitUsingDeclarationsWithIteratorObject.types @@ -38,9 +38,9 @@ async function f() { await using it2 = Iterator.from(i) >it2 : IteratorObject >Iterator.from(i) : IteratorObject ->Iterator.from : (value: Iterator | Iterable) => IteratorObject +>Iterator.from : (value: Iterable | Iterator) => IteratorObject >Iterator : IteratorConstructor ->from : (value: Iterator | Iterable) => IteratorObject +>from : (value: Iterable | Iterator) => IteratorObject >i : Iterator await using it3 = new MyIterator(); diff --git a/tsc/testdata/baselines/reference/conformance/usingDeclarationsWithIteratorObject.symbols b/tsc/testdata/baselines/reference/conformance/usingDeclarationsWithIteratorObject.symbols index f37a20d478d3b..70dbe2a4bd98f 100644 --- a/tsc/testdata/baselines/reference/conformance/usingDeclarationsWithIteratorObject.symbols +++ b/tsc/testdata/baselines/reference/conformance/usingDeclarationsWithIteratorObject.symbols @@ -7,7 +7,7 @@ declare const i: Iterator; declare const io: IteratorObject; >io : Symbol(io, Decl(usingDeclarationsWithIteratorObject.ts, 1, 13)) ->IteratorObject : Symbol(IteratorObject, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.esnext.disposable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>IteratorObject : Symbol(IteratorObject, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.esnext.disposable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) declare const g: Generator; >g : Symbol(g, Decl(usingDeclarationsWithIteratorObject.ts, 2, 13)) diff --git a/tsc/testdata/baselines/reference/conformance/usingDeclarationsWithIteratorObject.types b/tsc/testdata/baselines/reference/conformance/usingDeclarationsWithIteratorObject.types index 0e8c9344cc652..d166f3b8c2fe2 100644 --- a/tsc/testdata/baselines/reference/conformance/usingDeclarationsWithIteratorObject.types +++ b/tsc/testdata/baselines/reference/conformance/usingDeclarationsWithIteratorObject.types @@ -38,9 +38,9 @@ function f() { using it2 = Iterator.from(i) >it2 : IteratorObject >Iterator.from(i) : IteratorObject ->Iterator.from : (value: Iterator | Iterable) => IteratorObject +>Iterator.from : (value: Iterable | Iterator) => IteratorObject >Iterator : IteratorConstructor ->from : (value: Iterator | Iterable) => IteratorObject +>from : (value: Iterable | Iterator) => IteratorObject >i : Iterator using it3 = new MyIterator(); diff --git a/tsc/testdata/baselines/reference/tsc/commandLine/Initialized-TSConfig-with-incorrect-compiler-option-value.js b/tsc/testdata/baselines/reference/tsc/commandLine/Initialized-TSConfig-with-incorrect-compiler-option-value.js index a5717b385b1ad..66b90f5ce5388 100644 --- a/tsc/testdata/baselines/reference/tsc/commandLine/Initialized-TSConfig-with-incorrect-compiler-option-value.js +++ b/tsc/testdata/baselines/reference/tsc/commandLine/Initialized-TSConfig-with-incorrect-compiler-option-value.js @@ -5,5 +5,5 @@ Input:: tsgo --init --lib nonExistLib,es5,es2015.promise ExitStatus:: DiagnosticsPresent_OutputsSkipped Output:: -error TS6046: Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'es2018', 'es2019', 'es2020', 'es2021', 'es2022', 'es2023', 'es2024', 'es2025', 'esnext', 'dom', 'dom.iterable', 'dom.asynciterable', 'webworker', 'webworker.importscripts', 'webworker.iterable', 'webworker.asynciterable', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2016.intl', 'es2017.arraybuffer', 'es2017.date', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'es2017.intl', 'es2017.typedarrays', 'es2018.asyncgenerator', 'es2018.asynciterable', 'es2018.intl', 'es2018.promise', 'es2018.regexp', 'es2019.array', 'es2019.object', 'es2019.string', 'es2019.symbol', 'es2019.intl', 'es2020.bigint', 'es2020.date', 'es2020.promise', 'es2020.sharedmemory', 'es2020.string', 'es2020.symbol.wellknown', 'es2020.intl', 'es2020.number', 'es2021.promise', 'es2021.string', 'es2021.weakref', 'es2021.intl', 'es2022.array', 'es2022.error', 'es2022.intl', 'es2022.object', 'es2022.string', 'es2022.regexp', 'es2023.array', 'es2023.collection', 'es2023.intl', 'es2024.arraybuffer', 'es2024.collection', 'es2024.object', 'es2024.promise', 'es2024.regexp', 'es2024.sharedmemory', 'es2024.string', 'es2025.collection', 'es2025.float16', 'es2025.intl', 'es2025.iterator', 'es2025.promise', 'es2025.regexp', 'esnext.asynciterable', 'esnext.symbol', 'esnext.bigint', 'esnext.weakref', 'esnext.object', 'esnext.regexp', 'esnext.string', 'esnext.float16', 'esnext.iterator', 'esnext.promise', 'esnext.array', 'esnext.collection', 'esnext.date', 'esnext.decorators', 'esnext.disposable', 'esnext.error', 'esnext.intl', 'esnext.sharedmemory', 'esnext.temporal', 'esnext.typedarrays', 'decorators', 'decorators.legacy'. +error TS6046: Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'es2018', 'es2019', 'es2020', 'es2021', 'es2022', 'es2023', 'es2024', 'es2025', 'esnext', 'dom', 'dom.iterable', 'dom.asynciterable', 'webworker', 'webworker.importscripts', 'webworker.iterable', 'webworker.asynciterable', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2016.intl', 'es2017.arraybuffer', 'es2017.date', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'es2017.intl', 'es2017.typedarrays', 'es2018.asyncgenerator', 'es2018.asynciterable', 'es2018.intl', 'es2018.promise', 'es2018.regexp', 'es2019.array', 'es2019.object', 'es2019.string', 'es2019.symbol', 'es2019.intl', 'es2020.bigint', 'es2020.date', 'es2020.promise', 'es2020.sharedmemory', 'es2020.string', 'es2020.symbol.wellknown', 'es2020.intl', 'es2020.number', 'es2021.promise', 'es2021.string', 'es2021.weakref', 'es2021.intl', 'es2022.array', 'es2022.error', 'es2022.intl', 'es2022.object', 'es2022.string', 'es2022.regexp', 'es2023.array', 'es2023.collection', 'es2023.intl', 'es2024.arraybuffer', 'es2024.collection', 'es2024.object', 'es2024.promise', 'es2024.regexp', 'es2024.sharedmemory', 'es2024.string', 'es2025.collection', 'es2025.float16', 'es2025.intl', 'es2025.iterator', 'es2025.promise', 'es2025.regexp', 'esnext.asynciterable', 'esnext.symbol', 'esnext.bigint', 'esnext.weakref', 'esnext.object', 'esnext.regexp', 'esnext.string', 'esnext.float16', 'esnext.promise', 'esnext.iterator', 'esnext.array', 'esnext.collection', 'esnext.date', 'esnext.decorators', 'esnext.disposable', 'esnext.error', 'esnext.intl', 'esnext.sharedmemory', 'esnext.temporal', 'esnext.typedarrays', 'decorators', 'decorators.legacy'. diff --git a/tsc/testdata/baselines/reference/tsc/commandLine/help-all.js b/tsc/testdata/baselines/reference/tsc/commandLine/help-all.js index db9dd22705973..852bf1b5bbaa4 100644 --- a/tsc/testdata/baselines/reference/tsc/commandLine/help-all.js +++ b/tsc/testdata/baselines/reference/tsc/commandLine/help-all.js @@ -545,7 +545,7 @@ default: react --lib Specify a set of bundled library declaration files that describe the target runtime environment. -one or more: es5, es6/es2015, es7/es2016, es2017, es2018, es2019, es2020, es2021, es2022, es2023, es2024, es2025, esnext, dom, dom.iterable, dom.asynciterable, webworker, webworker.importscripts, webworker.iterable, webworker.asynciterable, scripthost, es2015.core, es2015.collection, es2015.generator, es2015.iterable, es2015.promise, es2015.proxy, es2015.reflect, es2015.symbol, es2015.symbol.wellknown, es2016.array.include, es2016.intl, es2017.arraybuffer, es2017.date, es2017.object, es2017.sharedmemory, es2017.string, es2017.intl, es2017.typedarrays, es2018.asyncgenerator, es2018.asynciterable/esnext.asynciterable, es2018.intl, es2018.promise, es2018.regexp, es2019.array, es2019.object, es2019.string, es2019.symbol/esnext.symbol, es2019.intl, es2020.bigint/esnext.bigint, es2020.date, es2020.promise, es2020.sharedmemory, es2020.string, es2020.symbol.wellknown, es2020.intl, es2020.number, es2021.promise, es2021.string, es2021.weakref/esnext.weakref, es2021.intl, es2022.array, es2022.error, es2022.intl, es2022.object, es2022.string, es2022.regexp, es2023.array, es2023.collection, es2023.intl, es2024.arraybuffer, es2024.collection, es2024.object/esnext.object, es2024.promise, es2024.regexp/esnext.regexp, es2024.sharedmemory, es2024.string/esnext.string, es2025.collection, es2025.float16/esnext.float16, es2025.intl, es2025.iterator/esnext.iterator, es2025.promise/esnext.promise, es2025.regexp, esnext.array, esnext.collection, esnext.date, esnext.decorators, esnext.disposable, esnext.error, esnext.intl, esnext.sharedmemory, esnext.temporal, esnext.typedarrays, decorators, decorators.legacy +one or more: es5, es6/es2015, es7/es2016, es2017, es2018, es2019, es2020, es2021, es2022, es2023, es2024, es2025, esnext, dom, dom.iterable, dom.asynciterable, webworker, webworker.importscripts, webworker.iterable, webworker.asynciterable, scripthost, es2015.core, es2015.collection, es2015.generator, es2015.iterable, es2015.promise, es2015.proxy, es2015.reflect, es2015.symbol, es2015.symbol.wellknown, es2016.array.include, es2016.intl, es2017.arraybuffer, es2017.date, es2017.object, es2017.sharedmemory, es2017.string, es2017.intl, es2017.typedarrays, es2018.asyncgenerator, es2018.asynciterable/esnext.asynciterable, es2018.intl, es2018.promise, es2018.regexp, es2019.array, es2019.object, es2019.string, es2019.symbol/esnext.symbol, es2019.intl, es2020.bigint/esnext.bigint, es2020.date, es2020.promise, es2020.sharedmemory, es2020.string, es2020.symbol.wellknown, es2020.intl, es2020.number, es2021.promise, es2021.string, es2021.weakref/esnext.weakref, es2021.intl, es2022.array, es2022.error, es2022.intl, es2022.object, es2022.string, es2022.regexp, es2023.array, es2023.collection, es2023.intl, es2024.arraybuffer, es2024.collection, es2024.object/esnext.object, es2024.promise, es2024.regexp/esnext.regexp, es2024.sharedmemory, es2024.string/esnext.string, es2025.collection, es2025.float16/esnext.float16, es2025.intl, es2025.iterator, es2025.promise/esnext.promise, es2025.regexp, esnext.iterator, esnext.array, esnext.collection, esnext.date, esnext.decorators, esnext.disposable, esnext.error, esnext.intl, esnext.sharedmemory, esnext.temporal, esnext.typedarrays, decorators, decorators.legacy default: undefined --libReplacement diff --git a/tsc/testdata/baselines/reference/tsc/commandLine/help.js b/tsc/testdata/baselines/reference/tsc/commandLine/help.js index 39b57c563af20..43229367a83ff 100644 --- a/tsc/testdata/baselines/reference/tsc/commandLine/help.js +++ b/tsc/testdata/baselines/reference/tsc/commandLine/help.js @@ -104,7 +104,7 @@ default: undefined --lib Specify a set of bundled library declaration files that describe the target runtime environment. -one or more: es5, es6/es2015, es7/es2016, es2017, es2018, es2019, es2020, es2021, es2022, es2023, es2024, es2025, esnext, dom, dom.iterable, dom.asynciterable, webworker, webworker.importscripts, webworker.iterable, webworker.asynciterable, scripthost, es2015.core, es2015.collection, es2015.generator, es2015.iterable, es2015.promise, es2015.proxy, es2015.reflect, es2015.symbol, es2015.symbol.wellknown, es2016.array.include, es2016.intl, es2017.arraybuffer, es2017.date, es2017.object, es2017.sharedmemory, es2017.string, es2017.intl, es2017.typedarrays, es2018.asyncgenerator, es2018.asynciterable/esnext.asynciterable, es2018.intl, es2018.promise, es2018.regexp, es2019.array, es2019.object, es2019.string, es2019.symbol/esnext.symbol, es2019.intl, es2020.bigint/esnext.bigint, es2020.date, es2020.promise, es2020.sharedmemory, es2020.string, es2020.symbol.wellknown, es2020.intl, es2020.number, es2021.promise, es2021.string, es2021.weakref/esnext.weakref, es2021.intl, es2022.array, es2022.error, es2022.intl, es2022.object, es2022.string, es2022.regexp, es2023.array, es2023.collection, es2023.intl, es2024.arraybuffer, es2024.collection, es2024.object/esnext.object, es2024.promise, es2024.regexp/esnext.regexp, es2024.sharedmemory, es2024.string/esnext.string, es2025.collection, es2025.float16/esnext.float16, es2025.intl, es2025.iterator/esnext.iterator, es2025.promise/esnext.promise, es2025.regexp, esnext.array, esnext.collection, esnext.date, esnext.decorators, esnext.disposable, esnext.error, esnext.intl, esnext.sharedmemory, esnext.temporal, esnext.typedarrays, decorators, decorators.legacy +one or more: es5, es6/es2015, es7/es2016, es2017, es2018, es2019, es2020, es2021, es2022, es2023, es2024, es2025, esnext, dom, dom.iterable, dom.asynciterable, webworker, webworker.importscripts, webworker.iterable, webworker.asynciterable, scripthost, es2015.core, es2015.collection, es2015.generator, es2015.iterable, es2015.promise, es2015.proxy, es2015.reflect, es2015.symbol, es2015.symbol.wellknown, es2016.array.include, es2016.intl, es2017.arraybuffer, es2017.date, es2017.object, es2017.sharedmemory, es2017.string, es2017.intl, es2017.typedarrays, es2018.asyncgenerator, es2018.asynciterable/esnext.asynciterable, es2018.intl, es2018.promise, es2018.regexp, es2019.array, es2019.object, es2019.string, es2019.symbol/esnext.symbol, es2019.intl, es2020.bigint/esnext.bigint, es2020.date, es2020.promise, es2020.sharedmemory, es2020.string, es2020.symbol.wellknown, es2020.intl, es2020.number, es2021.promise, es2021.string, es2021.weakref/esnext.weakref, es2021.intl, es2022.array, es2022.error, es2022.intl, es2022.object, es2022.string, es2022.regexp, es2023.array, es2023.collection, es2023.intl, es2024.arraybuffer, es2024.collection, es2024.object/esnext.object, es2024.promise, es2024.regexp/esnext.regexp, es2024.sharedmemory, es2024.string/esnext.string, es2025.collection, es2025.float16/esnext.float16, es2025.intl, es2025.iterator, es2025.promise/esnext.promise, es2025.regexp, esnext.iterator, esnext.array, esnext.collection, esnext.date, esnext.decorators, esnext.disposable, esnext.error, esnext.intl, esnext.sharedmemory, esnext.temporal, esnext.typedarrays, decorators, decorators.legacy default: undefined --allowJs diff --git a/tsc/testdata/baselines/reference/tsc/commandLine/show-help-with-ExitStatus.DiagnosticsPresent_OutputsSkipped-when-host-cannot-provide-terminal-width.js b/tsc/testdata/baselines/reference/tsc/commandLine/show-help-with-ExitStatus.DiagnosticsPresent_OutputsSkipped-when-host-cannot-provide-terminal-width.js index f158bb77874f5..b69dcca51cf8a 100644 --- a/tsc/testdata/baselines/reference/tsc/commandLine/show-help-with-ExitStatus.DiagnosticsPresent_OutputsSkipped-when-host-cannot-provide-terminal-width.js +++ b/tsc/testdata/baselines/reference/tsc/commandLine/show-help-with-ExitStatus.DiagnosticsPresent_OutputsSkipped-when-host-cannot-provide-terminal-width.js @@ -105,7 +105,7 @@ default: undefined --lib Specify a set of bundled library declaration files that describe the target runtime environment. -one or more: es5, es6/es2015, es7/es2016, es2017, es2018, es2019, es2020, es2021, es2022, es2023, es2024, es2025, esnext, dom, dom.iterable, dom.asynciterable, webworker, webworker.importscripts, webworker.iterable, webworker.asynciterable, scripthost, es2015.core, es2015.collection, es2015.generator, es2015.iterable, es2015.promise, es2015.proxy, es2015.reflect, es2015.symbol, es2015.symbol.wellknown, es2016.array.include, es2016.intl, es2017.arraybuffer, es2017.date, es2017.object, es2017.sharedmemory, es2017.string, es2017.intl, es2017.typedarrays, es2018.asyncgenerator, es2018.asynciterable/esnext.asynciterable, es2018.intl, es2018.promise, es2018.regexp, es2019.array, es2019.object, es2019.string, es2019.symbol/esnext.symbol, es2019.intl, es2020.bigint/esnext.bigint, es2020.date, es2020.promise, es2020.sharedmemory, es2020.string, es2020.symbol.wellknown, es2020.intl, es2020.number, es2021.promise, es2021.string, es2021.weakref/esnext.weakref, es2021.intl, es2022.array, es2022.error, es2022.intl, es2022.object, es2022.string, es2022.regexp, es2023.array, es2023.collection, es2023.intl, es2024.arraybuffer, es2024.collection, es2024.object/esnext.object, es2024.promise, es2024.regexp/esnext.regexp, es2024.sharedmemory, es2024.string/esnext.string, es2025.collection, es2025.float16/esnext.float16, es2025.intl, es2025.iterator/esnext.iterator, es2025.promise/esnext.promise, es2025.regexp, esnext.array, esnext.collection, esnext.date, esnext.decorators, esnext.disposable, esnext.error, esnext.intl, esnext.sharedmemory, esnext.temporal, esnext.typedarrays, decorators, decorators.legacy +one or more: es5, es6/es2015, es7/es2016, es2017, es2018, es2019, es2020, es2021, es2022, es2023, es2024, es2025, esnext, dom, dom.iterable, dom.asynciterable, webworker, webworker.importscripts, webworker.iterable, webworker.asynciterable, scripthost, es2015.core, es2015.collection, es2015.generator, es2015.iterable, es2015.promise, es2015.proxy, es2015.reflect, es2015.symbol, es2015.symbol.wellknown, es2016.array.include, es2016.intl, es2017.arraybuffer, es2017.date, es2017.object, es2017.sharedmemory, es2017.string, es2017.intl, es2017.typedarrays, es2018.asyncgenerator, es2018.asynciterable/esnext.asynciterable, es2018.intl, es2018.promise, es2018.regexp, es2019.array, es2019.object, es2019.string, es2019.symbol/esnext.symbol, es2019.intl, es2020.bigint/esnext.bigint, es2020.date, es2020.promise, es2020.sharedmemory, es2020.string, es2020.symbol.wellknown, es2020.intl, es2020.number, es2021.promise, es2021.string, es2021.weakref/esnext.weakref, es2021.intl, es2022.array, es2022.error, es2022.intl, es2022.object, es2022.string, es2022.regexp, es2023.array, es2023.collection, es2023.intl, es2024.arraybuffer, es2024.collection, es2024.object/esnext.object, es2024.promise, es2024.regexp/esnext.regexp, es2024.sharedmemory, es2024.string/esnext.string, es2025.collection, es2025.float16/esnext.float16, es2025.intl, es2025.iterator, es2025.promise/esnext.promise, es2025.regexp, esnext.iterator, esnext.array, esnext.collection, esnext.date, esnext.decorators, esnext.disposable, esnext.error, esnext.intl, esnext.sharedmemory, esnext.temporal, esnext.typedarrays, decorators, decorators.legacy default: undefined --allowJs diff --git a/tsc/testdata/baselines/reference/tsc/commandLine/show-help-with-ExitStatus.DiagnosticsPresent_OutputsSkipped.js b/tsc/testdata/baselines/reference/tsc/commandLine/show-help-with-ExitStatus.DiagnosticsPresent_OutputsSkipped.js index 2184f188fd065..647ebeb4b034f 100644 --- a/tsc/testdata/baselines/reference/tsc/commandLine/show-help-with-ExitStatus.DiagnosticsPresent_OutputsSkipped.js +++ b/tsc/testdata/baselines/reference/tsc/commandLine/show-help-with-ExitStatus.DiagnosticsPresent_OutputsSkipped.js @@ -138,9 +138,9 @@ tsc: The TypeScript Compiler - Version FakeTSVersion xp, es2023.array, es2023.collection, es2023.intl, es2024.arraybuffer, es2024.collection, es2024 .object/esnext.object, es2024.promise, es2024.regexp/esnext.regexp, es2024.sharedmemory, es2024 .string/esnext.string, es2025.collection, es2025.float16/esnext.float16, es2025.intl, es2025.it - erator/esnext.iterator, es2025.promise/esnext.promise, es2025.regexp, esnext.array, esnext.coll - ection, esnext.date, esnext.decorators, esnext.disposable, esnext.error, esnext.intl, esnext.sh - aredmemory, esnext.temporal, esnext.typedarrays, decorators, decorators.legacy + erator, es2025.promise/esnext.promise, es2025.regexp, esnext.iterator, esnext.array, esnext.col + lection, esnext.date, esnext.decorators, esnext.disposable, esnext.error, esnext.intl, esnext.s + haredmemory, esnext.temporal, esnext.typedarrays, decorators, decorators.legacy default: undefined diff --git a/tsc/testdata/baselines/reference/tsc/ignoreConfig/without-any-options-when-config-file-absent-with---ignoreConfig.js b/tsc/testdata/baselines/reference/tsc/ignoreConfig/without-any-options-when-config-file-absent-with---ignoreConfig.js index 0d8d282bf4e12..8df59b6b6c45e 100644 --- a/tsc/testdata/baselines/reference/tsc/ignoreConfig/without-any-options-when-config-file-absent-with---ignoreConfig.js +++ b/tsc/testdata/baselines/reference/tsc/ignoreConfig/without-any-options-when-config-file-absent-with---ignoreConfig.js @@ -111,7 +111,7 @@ default: undefined --lib Specify a set of bundled library declaration files that describe the target runtime environment. -one or more: es5, es6/es2015, es7/es2016, es2017, es2018, es2019, es2020, es2021, es2022, es2023, es2024, es2025, esnext, dom, dom.iterable, dom.asynciterable, webworker, webworker.importscripts, webworker.iterable, webworker.asynciterable, scripthost, es2015.core, es2015.collection, es2015.generator, es2015.iterable, es2015.promise, es2015.proxy, es2015.reflect, es2015.symbol, es2015.symbol.wellknown, es2016.array.include, es2016.intl, es2017.arraybuffer, es2017.date, es2017.object, es2017.sharedmemory, es2017.string, es2017.intl, es2017.typedarrays, es2018.asyncgenerator, es2018.asynciterable/esnext.asynciterable, es2018.intl, es2018.promise, es2018.regexp, es2019.array, es2019.object, es2019.string, es2019.symbol/esnext.symbol, es2019.intl, es2020.bigint/esnext.bigint, es2020.date, es2020.promise, es2020.sharedmemory, es2020.string, es2020.symbol.wellknown, es2020.intl, es2020.number, es2021.promise, es2021.string, es2021.weakref/esnext.weakref, es2021.intl, es2022.array, es2022.error, es2022.intl, es2022.object, es2022.string, es2022.regexp, es2023.array, es2023.collection, es2023.intl, es2024.arraybuffer, es2024.collection, es2024.object/esnext.object, es2024.promise, es2024.regexp/esnext.regexp, es2024.sharedmemory, es2024.string/esnext.string, es2025.collection, es2025.float16/esnext.float16, es2025.intl, es2025.iterator/esnext.iterator, es2025.promise/esnext.promise, es2025.regexp, esnext.array, esnext.collection, esnext.date, esnext.decorators, esnext.disposable, esnext.error, esnext.intl, esnext.sharedmemory, esnext.temporal, esnext.typedarrays, decorators, decorators.legacy +one or more: es5, es6/es2015, es7/es2016, es2017, es2018, es2019, es2020, es2021, es2022, es2023, es2024, es2025, esnext, dom, dom.iterable, dom.asynciterable, webworker, webworker.importscripts, webworker.iterable, webworker.asynciterable, scripthost, es2015.core, es2015.collection, es2015.generator, es2015.iterable, es2015.promise, es2015.proxy, es2015.reflect, es2015.symbol, es2015.symbol.wellknown, es2016.array.include, es2016.intl, es2017.arraybuffer, es2017.date, es2017.object, es2017.sharedmemory, es2017.string, es2017.intl, es2017.typedarrays, es2018.asyncgenerator, es2018.asynciterable/esnext.asynciterable, es2018.intl, es2018.promise, es2018.regexp, es2019.array, es2019.object, es2019.string, es2019.symbol/esnext.symbol, es2019.intl, es2020.bigint/esnext.bigint, es2020.date, es2020.promise, es2020.sharedmemory, es2020.string, es2020.symbol.wellknown, es2020.intl, es2020.number, es2021.promise, es2021.string, es2021.weakref/esnext.weakref, es2021.intl, es2022.array, es2022.error, es2022.intl, es2022.object, es2022.string, es2022.regexp, es2023.array, es2023.collection, es2023.intl, es2024.arraybuffer, es2024.collection, es2024.object/esnext.object, es2024.promise, es2024.regexp/esnext.regexp, es2024.sharedmemory, es2024.string/esnext.string, es2025.collection, es2025.float16/esnext.float16, es2025.intl, es2025.iterator, es2025.promise/esnext.promise, es2025.regexp, esnext.iterator, esnext.array, esnext.collection, esnext.date, esnext.decorators, esnext.disposable, esnext.error, esnext.intl, esnext.sharedmemory, esnext.temporal, esnext.typedarrays, decorators, decorators.legacy default: undefined --allowJs diff --git a/tsc/testdata/baselines/reference/tsc/ignoreConfig/without-any-options-when-config-file-absent.js b/tsc/testdata/baselines/reference/tsc/ignoreConfig/without-any-options-when-config-file-absent.js index 1554ee4753d44..16a4c1e37e2ea 100644 --- a/tsc/testdata/baselines/reference/tsc/ignoreConfig/without-any-options-when-config-file-absent.js +++ b/tsc/testdata/baselines/reference/tsc/ignoreConfig/without-any-options-when-config-file-absent.js @@ -111,7 +111,7 @@ default: undefined --lib Specify a set of bundled library declaration files that describe the target runtime environment. -one or more: es5, es6/es2015, es7/es2016, es2017, es2018, es2019, es2020, es2021, es2022, es2023, es2024, es2025, esnext, dom, dom.iterable, dom.asynciterable, webworker, webworker.importscripts, webworker.iterable, webworker.asynciterable, scripthost, es2015.core, es2015.collection, es2015.generator, es2015.iterable, es2015.promise, es2015.proxy, es2015.reflect, es2015.symbol, es2015.symbol.wellknown, es2016.array.include, es2016.intl, es2017.arraybuffer, es2017.date, es2017.object, es2017.sharedmemory, es2017.string, es2017.intl, es2017.typedarrays, es2018.asyncgenerator, es2018.asynciterable/esnext.asynciterable, es2018.intl, es2018.promise, es2018.regexp, es2019.array, es2019.object, es2019.string, es2019.symbol/esnext.symbol, es2019.intl, es2020.bigint/esnext.bigint, es2020.date, es2020.promise, es2020.sharedmemory, es2020.string, es2020.symbol.wellknown, es2020.intl, es2020.number, es2021.promise, es2021.string, es2021.weakref/esnext.weakref, es2021.intl, es2022.array, es2022.error, es2022.intl, es2022.object, es2022.string, es2022.regexp, es2023.array, es2023.collection, es2023.intl, es2024.arraybuffer, es2024.collection, es2024.object/esnext.object, es2024.promise, es2024.regexp/esnext.regexp, es2024.sharedmemory, es2024.string/esnext.string, es2025.collection, es2025.float16/esnext.float16, es2025.intl, es2025.iterator/esnext.iterator, es2025.promise/esnext.promise, es2025.regexp, esnext.array, esnext.collection, esnext.date, esnext.decorators, esnext.disposable, esnext.error, esnext.intl, esnext.sharedmemory, esnext.temporal, esnext.typedarrays, decorators, decorators.legacy +one or more: es5, es6/es2015, es7/es2016, es2017, es2018, es2019, es2020, es2021, es2022, es2023, es2024, es2025, esnext, dom, dom.iterable, dom.asynciterable, webworker, webworker.importscripts, webworker.iterable, webworker.asynciterable, scripthost, es2015.core, es2015.collection, es2015.generator, es2015.iterable, es2015.promise, es2015.proxy, es2015.reflect, es2015.symbol, es2015.symbol.wellknown, es2016.array.include, es2016.intl, es2017.arraybuffer, es2017.date, es2017.object, es2017.sharedmemory, es2017.string, es2017.intl, es2017.typedarrays, es2018.asyncgenerator, es2018.asynciterable/esnext.asynciterable, es2018.intl, es2018.promise, es2018.regexp, es2019.array, es2019.object, es2019.string, es2019.symbol/esnext.symbol, es2019.intl, es2020.bigint/esnext.bigint, es2020.date, es2020.promise, es2020.sharedmemory, es2020.string, es2020.symbol.wellknown, es2020.intl, es2020.number, es2021.promise, es2021.string, es2021.weakref/esnext.weakref, es2021.intl, es2022.array, es2022.error, es2022.intl, es2022.object, es2022.string, es2022.regexp, es2023.array, es2023.collection, es2023.intl, es2024.arraybuffer, es2024.collection, es2024.object/esnext.object, es2024.promise, es2024.regexp/esnext.regexp, es2024.sharedmemory, es2024.string/esnext.string, es2025.collection, es2025.float16/esnext.float16, es2025.intl, es2025.iterator, es2025.promise/esnext.promise, es2025.regexp, esnext.iterator, esnext.array, esnext.collection, esnext.date, esnext.decorators, esnext.disposable, esnext.error, esnext.intl, esnext.sharedmemory, esnext.temporal, esnext.typedarrays, decorators, decorators.legacy default: undefined --allowJs diff --git a/tsc/testdata/baselines/reference/tsc/showConfig/Show-TSConfig-with-incorrect-compiler-option-value.js b/tsc/testdata/baselines/reference/tsc/showConfig/Show-TSConfig-with-incorrect-compiler-option-value.js index 7902a5f89cdfd..c48c19c7e5a51 100644 --- a/tsc/testdata/baselines/reference/tsc/showConfig/Show-TSConfig-with-incorrect-compiler-option-value.js +++ b/tsc/testdata/baselines/reference/tsc/showConfig/Show-TSConfig-with-incorrect-compiler-option-value.js @@ -5,5 +5,5 @@ Input:: tsgo --showConfig --lib nonExistLib,es5,es2015.promise ExitStatus:: DiagnosticsPresent_OutputsSkipped Output:: -error TS6046: Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'es2018', 'es2019', 'es2020', 'es2021', 'es2022', 'es2023', 'es2024', 'es2025', 'esnext', 'dom', 'dom.iterable', 'dom.asynciterable', 'webworker', 'webworker.importscripts', 'webworker.iterable', 'webworker.asynciterable', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2016.intl', 'es2017.arraybuffer', 'es2017.date', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'es2017.intl', 'es2017.typedarrays', 'es2018.asyncgenerator', 'es2018.asynciterable', 'es2018.intl', 'es2018.promise', 'es2018.regexp', 'es2019.array', 'es2019.object', 'es2019.string', 'es2019.symbol', 'es2019.intl', 'es2020.bigint', 'es2020.date', 'es2020.promise', 'es2020.sharedmemory', 'es2020.string', 'es2020.symbol.wellknown', 'es2020.intl', 'es2020.number', 'es2021.promise', 'es2021.string', 'es2021.weakref', 'es2021.intl', 'es2022.array', 'es2022.error', 'es2022.intl', 'es2022.object', 'es2022.string', 'es2022.regexp', 'es2023.array', 'es2023.collection', 'es2023.intl', 'es2024.arraybuffer', 'es2024.collection', 'es2024.object', 'es2024.promise', 'es2024.regexp', 'es2024.sharedmemory', 'es2024.string', 'es2025.collection', 'es2025.float16', 'es2025.intl', 'es2025.iterator', 'es2025.promise', 'es2025.regexp', 'esnext.asynciterable', 'esnext.symbol', 'esnext.bigint', 'esnext.weakref', 'esnext.object', 'esnext.regexp', 'esnext.string', 'esnext.float16', 'esnext.iterator', 'esnext.promise', 'esnext.array', 'esnext.collection', 'esnext.date', 'esnext.decorators', 'esnext.disposable', 'esnext.error', 'esnext.intl', 'esnext.sharedmemory', 'esnext.temporal', 'esnext.typedarrays', 'decorators', 'decorators.legacy'. +error TS6046: Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'es2018', 'es2019', 'es2020', 'es2021', 'es2022', 'es2023', 'es2024', 'es2025', 'esnext', 'dom', 'dom.iterable', 'dom.asynciterable', 'webworker', 'webworker.importscripts', 'webworker.iterable', 'webworker.asynciterable', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2016.intl', 'es2017.arraybuffer', 'es2017.date', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'es2017.intl', 'es2017.typedarrays', 'es2018.asyncgenerator', 'es2018.asynciterable', 'es2018.intl', 'es2018.promise', 'es2018.regexp', 'es2019.array', 'es2019.object', 'es2019.string', 'es2019.symbol', 'es2019.intl', 'es2020.bigint', 'es2020.date', 'es2020.promise', 'es2020.sharedmemory', 'es2020.string', 'es2020.symbol.wellknown', 'es2020.intl', 'es2020.number', 'es2021.promise', 'es2021.string', 'es2021.weakref', 'es2021.intl', 'es2022.array', 'es2022.error', 'es2022.intl', 'es2022.object', 'es2022.string', 'es2022.regexp', 'es2023.array', 'es2023.collection', 'es2023.intl', 'es2024.arraybuffer', 'es2024.collection', 'es2024.object', 'es2024.promise', 'es2024.regexp', 'es2024.sharedmemory', 'es2024.string', 'es2025.collection', 'es2025.float16', 'es2025.intl', 'es2025.iterator', 'es2025.promise', 'es2025.regexp', 'esnext.asynciterable', 'esnext.symbol', 'esnext.bigint', 'esnext.weakref', 'esnext.object', 'esnext.regexp', 'esnext.string', 'esnext.float16', 'esnext.promise', 'esnext.iterator', 'esnext.array', 'esnext.collection', 'esnext.date', 'esnext.decorators', 'esnext.disposable', 'esnext.error', 'esnext.intl', 'esnext.sharedmemory', 'esnext.temporal', 'esnext.typedarrays', 'decorators', 'decorators.legacy'. diff --git a/tsc/testdata/baselines/reference/tscWatch/commandLine/Parse-watch-interval-option-without-tsconfig.json.js b/tsc/testdata/baselines/reference/tscWatch/commandLine/Parse-watch-interval-option-without-tsconfig.json.js index f6ab5b0aed9ea..9116be4108ee0 100644 --- a/tsc/testdata/baselines/reference/tscWatch/commandLine/Parse-watch-interval-option-without-tsconfig.json.js +++ b/tsc/testdata/baselines/reference/tscWatch/commandLine/Parse-watch-interval-option-without-tsconfig.json.js @@ -105,7 +105,7 @@ default: undefined --lib Specify a set of bundled library declaration files that describe the target runtime environment. -one or more: es5, es6/es2015, es7/es2016, es2017, es2018, es2019, es2020, es2021, es2022, es2023, es2024, es2025, esnext, dom, dom.iterable, dom.asynciterable, webworker, webworker.importscripts, webworker.iterable, webworker.asynciterable, scripthost, es2015.core, es2015.collection, es2015.generator, es2015.iterable, es2015.promise, es2015.proxy, es2015.reflect, es2015.symbol, es2015.symbol.wellknown, es2016.array.include, es2016.intl, es2017.arraybuffer, es2017.date, es2017.object, es2017.sharedmemory, es2017.string, es2017.intl, es2017.typedarrays, es2018.asyncgenerator, es2018.asynciterable/esnext.asynciterable, es2018.intl, es2018.promise, es2018.regexp, es2019.array, es2019.object, es2019.string, es2019.symbol/esnext.symbol, es2019.intl, es2020.bigint/esnext.bigint, es2020.date, es2020.promise, es2020.sharedmemory, es2020.string, es2020.symbol.wellknown, es2020.intl, es2020.number, es2021.promise, es2021.string, es2021.weakref/esnext.weakref, es2021.intl, es2022.array, es2022.error, es2022.intl, es2022.object, es2022.string, es2022.regexp, es2023.array, es2023.collection, es2023.intl, es2024.arraybuffer, es2024.collection, es2024.object/esnext.object, es2024.promise, es2024.regexp/esnext.regexp, es2024.sharedmemory, es2024.string/esnext.string, es2025.collection, es2025.float16/esnext.float16, es2025.intl, es2025.iterator/esnext.iterator, es2025.promise/esnext.promise, es2025.regexp, esnext.array, esnext.collection, esnext.date, esnext.decorators, esnext.disposable, esnext.error, esnext.intl, esnext.sharedmemory, esnext.temporal, esnext.typedarrays, decorators, decorators.legacy +one or more: es5, es6/es2015, es7/es2016, es2017, es2018, es2019, es2020, es2021, es2022, es2023, es2024, es2025, esnext, dom, dom.iterable, dom.asynciterable, webworker, webworker.importscripts, webworker.iterable, webworker.asynciterable, scripthost, es2015.core, es2015.collection, es2015.generator, es2015.iterable, es2015.promise, es2015.proxy, es2015.reflect, es2015.symbol, es2015.symbol.wellknown, es2016.array.include, es2016.intl, es2017.arraybuffer, es2017.date, es2017.object, es2017.sharedmemory, es2017.string, es2017.intl, es2017.typedarrays, es2018.asyncgenerator, es2018.asynciterable/esnext.asynciterable, es2018.intl, es2018.promise, es2018.regexp, es2019.array, es2019.object, es2019.string, es2019.symbol/esnext.symbol, es2019.intl, es2020.bigint/esnext.bigint, es2020.date, es2020.promise, es2020.sharedmemory, es2020.string, es2020.symbol.wellknown, es2020.intl, es2020.number, es2021.promise, es2021.string, es2021.weakref/esnext.weakref, es2021.intl, es2022.array, es2022.error, es2022.intl, es2022.object, es2022.string, es2022.regexp, es2023.array, es2023.collection, es2023.intl, es2024.arraybuffer, es2024.collection, es2024.object/esnext.object, es2024.promise, es2024.regexp/esnext.regexp, es2024.sharedmemory, es2024.string/esnext.string, es2025.collection, es2025.float16/esnext.float16, es2025.intl, es2025.iterator, es2025.promise/esnext.promise, es2025.regexp, esnext.iterator, esnext.array, esnext.collection, esnext.date, esnext.decorators, esnext.disposable, esnext.error, esnext.intl, esnext.sharedmemory, esnext.temporal, esnext.typedarrays, decorators, decorators.legacy default: undefined --allowJs diff --git a/tsc/testdata/baselines/reference/tscWatch/commandLineWatch/watch-handles-tsconfig-deleted.js b/tsc/testdata/baselines/reference/tscWatch/commandLineWatch/watch-handles-tsconfig-deleted.js index 7c3ab632e031c..2d0b542b16a7e 100644 --- a/tsc/testdata/baselines/reference/tscWatch/commandLineWatch/watch-handles-tsconfig-deleted.js +++ b/tsc/testdata/baselines/reference/tscWatch/commandLineWatch/watch-handles-tsconfig-deleted.js @@ -171,7 +171,7 @@ Diff:: incremental reports config read error while clean build without tsconfig - ---lib -Specify a set of bundled library declaration files that describe the target runtime environment. --one or more: es5, es6/es2015, es7/es2016, es2017, es2018, es2019, es2020, es2021, es2022, es2023, es2024, es2025, esnext, dom, dom.iterable, dom.asynciterable, webworker, webworker.importscripts, webworker.iterable, webworker.asynciterable, scripthost, es2015.core, es2015.collection, es2015.generator, es2015.iterable, es2015.promise, es2015.proxy, es2015.reflect, es2015.symbol, es2015.symbol.wellknown, es2016.array.include, es2016.intl, es2017.arraybuffer, es2017.date, es2017.object, es2017.sharedmemory, es2017.string, es2017.intl, es2017.typedarrays, es2018.asyncgenerator, es2018.asynciterable/esnext.asynciterable, es2018.intl, es2018.promise, es2018.regexp, es2019.array, es2019.object, es2019.string, es2019.symbol/esnext.symbol, es2019.intl, es2020.bigint/esnext.bigint, es2020.date, es2020.promise, es2020.sharedmemory, es2020.string, es2020.symbol.wellknown, es2020.intl, es2020.number, es2021.promise, es2021.string, es2021.weakref/esnext.weakref, es2021.intl, es2022.array, es2022.error, es2022.intl, es2022.object, es2022.string, es2022.regexp, es2023.array, es2023.collection, es2023.intl, es2024.arraybuffer, es2024.collection, es2024.object/esnext.object, es2024.promise, es2024.regexp/esnext.regexp, es2024.sharedmemory, es2024.string/esnext.string, es2025.collection, es2025.float16/esnext.float16, es2025.intl, es2025.iterator/esnext.iterator, es2025.promise/esnext.promise, es2025.regexp, esnext.array, esnext.collection, esnext.date, esnext.decorators, esnext.disposable, esnext.error, esnext.intl, esnext.sharedmemory, esnext.temporal, esnext.typedarrays, decorators, decorators.legacy +-one or more: es5, es6/es2015, es7/es2016, es2017, es2018, es2019, es2020, es2021, es2022, es2023, es2024, es2025, esnext, dom, dom.iterable, dom.asynciterable, webworker, webworker.importscripts, webworker.iterable, webworker.asynciterable, scripthost, es2015.core, es2015.collection, es2015.generator, es2015.iterable, es2015.promise, es2015.proxy, es2015.reflect, es2015.symbol, es2015.symbol.wellknown, es2016.array.include, es2016.intl, es2017.arraybuffer, es2017.date, es2017.object, es2017.sharedmemory, es2017.string, es2017.intl, es2017.typedarrays, es2018.asyncgenerator, es2018.asynciterable/esnext.asynciterable, es2018.intl, es2018.promise, es2018.regexp, es2019.array, es2019.object, es2019.string, es2019.symbol/esnext.symbol, es2019.intl, es2020.bigint/esnext.bigint, es2020.date, es2020.promise, es2020.sharedmemory, es2020.string, es2020.symbol.wellknown, es2020.intl, es2020.number, es2021.promise, es2021.string, es2021.weakref/esnext.weakref, es2021.intl, es2022.array, es2022.error, es2022.intl, es2022.object, es2022.string, es2022.regexp, es2023.array, es2023.collection, es2023.intl, es2024.arraybuffer, es2024.collection, es2024.object/esnext.object, es2024.promise, es2024.regexp/esnext.regexp, es2024.sharedmemory, es2024.string/esnext.string, es2025.collection, es2025.float16/esnext.float16, es2025.intl, es2025.iterator, es2025.promise/esnext.promise, es2025.regexp, esnext.iterator, esnext.array, esnext.collection, esnext.date, esnext.decorators, esnext.disposable, esnext.error, esnext.intl, esnext.sharedmemory, esnext.temporal, esnext.typedarrays, decorators, decorators.legacy -default: undefined - ---allowJs diff --git a/tsc/testdata/baselines/reference/tsoptions/commandLineParsing/parseCommandLine/Parse invalid option of library flags.js b/tsc/testdata/baselines/reference/tsoptions/commandLineParsing/parseCommandLine/Parse invalid option of library flags.js index f959f48966220..e1e22539fa211 100644 --- a/tsc/testdata/baselines/reference/tsoptions/commandLineParsing/parseCommandLine/Parse invalid option of library flags.js +++ b/tsc/testdata/baselines/reference/tsoptions/commandLineParsing/parseCommandLine/Parse invalid option of library flags.js @@ -8,4 +8,4 @@ FileNames:: 0.ts Errors:: -error TS6046: Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'es2018', 'es2019', 'es2020', 'es2021', 'es2022', 'es2023', 'es2024', 'es2025', 'esnext', 'dom', 'dom.iterable', 'dom.asynciterable', 'webworker', 'webworker.importscripts', 'webworker.iterable', 'webworker.asynciterable', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2016.intl', 'es2017.arraybuffer', 'es2017.date', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'es2017.intl', 'es2017.typedarrays', 'es2018.asyncgenerator', 'es2018.asynciterable', 'es2018.intl', 'es2018.promise', 'es2018.regexp', 'es2019.array', 'es2019.object', 'es2019.string', 'es2019.symbol', 'es2019.intl', 'es2020.bigint', 'es2020.date', 'es2020.promise', 'es2020.sharedmemory', 'es2020.string', 'es2020.symbol.wellknown', 'es2020.intl', 'es2020.number', 'es2021.promise', 'es2021.string', 'es2021.weakref', 'es2021.intl', 'es2022.array', 'es2022.error', 'es2022.intl', 'es2022.object', 'es2022.string', 'es2022.regexp', 'es2023.array', 'es2023.collection', 'es2023.intl', 'es2024.arraybuffer', 'es2024.collection', 'es2024.object', 'es2024.promise', 'es2024.regexp', 'es2024.sharedmemory', 'es2024.string', 'es2025.collection', 'es2025.float16', 'es2025.intl', 'es2025.iterator', 'es2025.promise', 'es2025.regexp', 'esnext.asynciterable', 'esnext.symbol', 'esnext.bigint', 'esnext.weakref', 'esnext.object', 'esnext.regexp', 'esnext.string', 'esnext.float16', 'esnext.iterator', 'esnext.promise', 'esnext.array', 'esnext.collection', 'esnext.date', 'esnext.decorators', 'esnext.disposable', 'esnext.error', 'esnext.intl', 'esnext.sharedmemory', 'esnext.temporal', 'esnext.typedarrays', 'decorators', 'decorators.legacy'. +error TS6046: Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'es2018', 'es2019', 'es2020', 'es2021', 'es2022', 'es2023', 'es2024', 'es2025', 'esnext', 'dom', 'dom.iterable', 'dom.asynciterable', 'webworker', 'webworker.importscripts', 'webworker.iterable', 'webworker.asynciterable', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2016.intl', 'es2017.arraybuffer', 'es2017.date', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'es2017.intl', 'es2017.typedarrays', 'es2018.asyncgenerator', 'es2018.asynciterable', 'es2018.intl', 'es2018.promise', 'es2018.regexp', 'es2019.array', 'es2019.object', 'es2019.string', 'es2019.symbol', 'es2019.intl', 'es2020.bigint', 'es2020.date', 'es2020.promise', 'es2020.sharedmemory', 'es2020.string', 'es2020.symbol.wellknown', 'es2020.intl', 'es2020.number', 'es2021.promise', 'es2021.string', 'es2021.weakref', 'es2021.intl', 'es2022.array', 'es2022.error', 'es2022.intl', 'es2022.object', 'es2022.string', 'es2022.regexp', 'es2023.array', 'es2023.collection', 'es2023.intl', 'es2024.arraybuffer', 'es2024.collection', 'es2024.object', 'es2024.promise', 'es2024.regexp', 'es2024.sharedmemory', 'es2024.string', 'es2025.collection', 'es2025.float16', 'es2025.intl', 'es2025.iterator', 'es2025.promise', 'es2025.regexp', 'esnext.asynciterable', 'esnext.symbol', 'esnext.bigint', 'esnext.weakref', 'esnext.object', 'esnext.regexp', 'esnext.string', 'esnext.float16', 'esnext.promise', 'esnext.iterator', 'esnext.array', 'esnext.collection', 'esnext.date', 'esnext.decorators', 'esnext.disposable', 'esnext.error', 'esnext.intl', 'esnext.sharedmemory', 'esnext.temporal', 'esnext.typedarrays', 'decorators', 'decorators.legacy'. diff --git a/tsc/testdata/tests/cases/compiler/iteratorChunks.ts b/tsc/testdata/tests/cases/compiler/iteratorChunks.ts new file mode 100644 index 0000000000000..0a0ae2213de98 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/iteratorChunks.ts @@ -0,0 +1,8 @@ +// @target: esnext +// @lib: es2015, esnext.iterator +// @strict: true + +const chunks: number[][] = Iterator.from([1, 2, 3]).chunks(2).toArray(); + +// @ts-expect-error chunk size must be a number +Iterator.from([1, 2, 3]).chunks("2"); diff --git a/tsc/testdata/tests/cases/compiler/iteratorIncludes.ts b/tsc/testdata/tests/cases/compiler/iteratorIncludes.ts new file mode 100644 index 0000000000000..f1cc2b41991b0 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/iteratorIncludes.ts @@ -0,0 +1,12 @@ +// @target: esnext +// @lib: es2015, esnext.iterator +// @strict: true + +const includes: boolean = Iterator.from([1, 2, 3]).includes(2); +const includesAfterSkipping: boolean = Iterator.from([1, 2, 3]).includes(2, 1); + +// @ts-expect-error the searched value must match the iterator value +Iterator.from([1, 2, 3]).includes("1"); + +// @ts-expect-error skipped elements must be a number +Iterator.from([1, 2, 3]).includes(2, "1"); diff --git a/tsc/testdata/tests/cases/compiler/iteratorJoin.ts b/tsc/testdata/tests/cases/compiler/iteratorJoin.ts new file mode 100644 index 0000000000000..5e5ebee1fc07c --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/iteratorJoin.ts @@ -0,0 +1,9 @@ +// @target: esnext +// @lib: es2015, esnext.iterator +// @strict: true + +const joined: string = Iterator.from([1, 2, 3]).join("-"); +const joinedWithDefaultSeparator: string = Iterator.from([1, 2, 3]).join(); + +// @ts-expect-error separator must be a string +Iterator.from([1, 2, 3]).join(0); diff --git a/tsc/testdata/tests/cases/compiler/iteratorZip.ts b/tsc/testdata/tests/cases/compiler/iteratorZip.ts new file mode 100644 index 0000000000000..2b7fda5c88c30 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/iteratorZip.ts @@ -0,0 +1,57 @@ +// @target: esnext +// @lib: es2015, esnext.iterator +// @strict: true + +declare const key: unique symbol; + +const tuples: [number, string][] = Iterator.zip([ + [1, 2], + new Set(["a", "b"]), +] as const).toArray(); + +tuples[0][0] = 2; + +Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }); +Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }); +Iterator.zip([[1], ["a"]] as const, { mode: "strict" }); + +const empty: never[] = Iterator.zip([]).toArray(); + +declare const iterables: Iterable>; +const arrays: number[][] = Iterator.zip(iterables).toArray(); + +const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ + a: [1, 2], + b: new Set(["a", "b"]), + [key]: [true, false], +} as const).toArray(); + +objects[0].a = 2; + +Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { + mode: "longest", + padding: { b: "a" }, +}); + +interface Inputs { + a: Iterable; + b: Iterator; +} + +declare const inputs: Inputs; +const rows: { a: number; b: string; }[] = Iterator.zipKeyed(inputs).toArray(); + +// @ts-expect-error invalid mode +Iterator.zip([[1]], { mode: "invalid" }); + +// @ts-expect-error padding values must match the input element types +Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }); + +// @ts-expect-error padding is only used in longest mode +Iterator.zip([[1]], { mode: "shortest", padding: [1] }); + +// @ts-expect-error the input must be iterable +Iterator.zip(0); + +// @ts-expect-error each keyed value must be iterable +Iterator.zipKeyed({ a: 0 }); From ac7cdfcf37dbf2cbffa694790e83d2c67fe3566c Mon Sep 17 00:00:00 2001 From: Oleksandr Tarasiuk Date: Mon, 31 Aug 2026 23:53:28 +0300 Subject: [PATCH 2/8] update iterator zip typings and test baselines --- .../bundled/libs/lib.esnext.iterator.d.ts | 29 +- .../compiler/iteratorChunks.errors.txt | 10 + .../reference/compiler/iteratorChunks.js | 2 - .../reference/compiler/iteratorChunks.symbols | 1 - .../reference/compiler/iteratorChunks.types | 1 - .../compiler/iteratorIncludes.errors.txt | 16 + .../reference/compiler/iteratorIncludes.js | 4 - .../compiler/iteratorIncludes.symbols | 2 - .../reference/compiler/iteratorIncludes.types | 2 - .../compiler/iteratorJoin.errors.txt | 11 + .../reference/compiler/iteratorJoin.js | 2 - .../reference/compiler/iteratorJoin.symbols | 1 - .../reference/compiler/iteratorJoin.types | 1 - .../reference/compiler/iteratorZip.errors.txt | 120 +++++++ .../reference/compiler/iteratorZip.js | 67 ++-- .../reference/compiler/iteratorZip.symbols | 296 ++++++++++++----- .../reference/compiler/iteratorZip.types | 309 +++++++++++++++--- .../tests/cases/compiler/iteratorChunks.ts | 1 - .../tests/cases/compiler/iteratorIncludes.ts | 2 - .../tests/cases/compiler/iteratorJoin.ts | 1 - .../tests/cases/compiler/iteratorZip.ts | 37 ++- 21 files changed, 731 insertions(+), 184 deletions(-) create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorChunks.errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorIncludes.errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorJoin.errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZip.errors.txt diff --git a/tsc/internal/bundled/libs/lib.esnext.iterator.d.ts b/tsc/internal/bundled/libs/lib.esnext.iterator.d.ts index c2f6a6df2fd54..8cb2052698a9c 100644 --- a/tsc/internal/bundled/libs/lib.esnext.iterator.d.ts +++ b/tsc/internal/bundled/libs/lib.esnext.iterator.d.ts @@ -40,25 +40,24 @@ interface IteratorZipLongestOptions { interface IteratorZipStrictOptions { /** * Requires every input to yield the same number of values. + * If not, a `TypeError` will be thrown when an input is exhausted before others. */ mode: "strict"; } -type IteratorZipOptions = IteratorZipShortestOptions | IteratorZipLongestOptions | IteratorZipStrictOptions; +type IteratorZipOptions = + | IteratorZipShortestOptions + | IteratorZipLongestOptions + | IteratorZipStrictOptions; type IteratorInput = Iterable | Iterator; -type IteratorYield> = - T extends Iterable ? U : - T extends Iterator ? U : - never; +type IteratorInputTuple = readonly [] | readonly [IteratorInput, ...IteratorInput[]]; -type IteratorZipResult[]> = { - -readonly [K in keyof T]: IteratorYield; -}; +type IteratorYield = T extends IteratorInput ? U : never; -type IteratorZipKeyedResult }> = { - -readonly [K in keyof T]: IteratorYield; +type IteratorZipResult = { + -readonly [K in keyof T]: IteratorYield | TExtra; }; declare global { @@ -97,20 +96,24 @@ declare global { * @param iterables An iterable of iterators or iterables to zip. * @param options Controls how differing input lengths are handled. */ - zip[] | []>(iterables: T, options?: IteratorZipOptions>>>): IteratorObject, undefined, unknown>; + zip(iterables: T, options: IteratorZipLongestOptions>> & { padding: NoInfer>; }): IteratorObject, undefined, unknown>; + zip[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; + zip[] | []>(iterables: T, options: IteratorZipOptions>>>): IteratorObject, undefined, unknown>; /** * Creates an iterator whose values are arrays containing values yielded at the same position by each input iterator or iterable. * @param iterables An iterable of iterators or iterables to zip. * @param options Controls how differing input lengths are handled. */ - zip>(iterables: Iterable, options?: IteratorZipOptions>>>): IteratorObject[], undefined, unknown>; + zip>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject[], undefined, unknown>; + zip>(iterables: Iterable, options: IteratorZipOptions>>>): IteratorObject<(IteratorYield | undefined)[], undefined, unknown>; /** * Creates an iterator whose values are objects containing values yielded at the same position by each iterator or iterable in the input object. * @param iterables An object whose enumerable own properties contain iterators or iterables to zip. * @param options Controls how differing input lengths are handled. */ - zipKeyed }>(iterables: T, options?: IteratorZipOptions>>>): IteratorObject, undefined, unknown>; + zipKeyed(iterables: T & Record>, options?: IteratorZipShortestOptions | (IteratorZipLongestOptions>> & { padding: NoInfer>; }) | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; + zipKeyed(iterables: T & Record>, options: IteratorZipOptions>>>): IteratorObject, undefined, unknown>; } } diff --git a/tsc/testdata/baselines/reference/compiler/iteratorChunks.errors.txt b/tsc/testdata/baselines/reference/compiler/iteratorChunks.errors.txt new file mode 100644 index 0000000000000..1058ea5afa59e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorChunks.errors.txt @@ -0,0 +1,10 @@ +iteratorChunks.ts(3,33): error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'. + + +==== iteratorChunks.ts (1 errors) ==== + const chunks: number[][] = Iterator.from([1, 2, 3]).chunks(2).toArray(); + + Iterator.from([1, 2, 3]).chunks("2"); + ~~~ +!!! error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/iteratorChunks.js b/tsc/testdata/baselines/reference/compiler/iteratorChunks.js index 7a8ed2e291199..276d3590cd6e5 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorChunks.js +++ b/tsc/testdata/baselines/reference/compiler/iteratorChunks.js @@ -3,12 +3,10 @@ //// [iteratorChunks.ts] const chunks: number[][] = Iterator.from([1, 2, 3]).chunks(2).toArray(); -// @ts-expect-error chunk size must be a number Iterator.from([1, 2, 3]).chunks("2"); //// [iteratorChunks.js] "use strict"; const chunks = Iterator.from([1, 2, 3]).chunks(2).toArray(); -// @ts-expect-error chunk size must be a number Iterator.from([1, 2, 3]).chunks("2"); diff --git a/tsc/testdata/baselines/reference/compiler/iteratorChunks.symbols b/tsc/testdata/baselines/reference/compiler/iteratorChunks.symbols index 4ba63bd206cc4..da7283633fad3 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorChunks.symbols +++ b/tsc/testdata/baselines/reference/compiler/iteratorChunks.symbols @@ -11,7 +11,6 @@ const chunks: number[][] = Iterator.from([1, 2, 3]).chunks(2).toArray(); >chunks : Symbol(IteratorObject.chunks, Decl(lib.esnext.iterator.d.ts, --, --)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -// @ts-expect-error chunk size must be a number Iterator.from([1, 2, 3]).chunks("2"); >Iterator.from([1, 2, 3]).chunks : Symbol(IteratorObject.chunks, Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator.from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) diff --git a/tsc/testdata/baselines/reference/compiler/iteratorChunks.types b/tsc/testdata/baselines/reference/compiler/iteratorChunks.types index 7be86f8bdfe48..a70cd739067c4 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorChunks.types +++ b/tsc/testdata/baselines/reference/compiler/iteratorChunks.types @@ -19,7 +19,6 @@ const chunks: number[][] = Iterator.from([1, 2, 3]).chunks(2).toArray(); >2 : 2 >toArray : () => number[][] -// @ts-expect-error chunk size must be a number Iterator.from([1, 2, 3]).chunks("2"); >Iterator.from([1, 2, 3]).chunks("2") : IteratorObject >Iterator.from([1, 2, 3]).chunks : (chunkSize: number) => IteratorObject diff --git a/tsc/testdata/baselines/reference/compiler/iteratorIncludes.errors.txt b/tsc/testdata/baselines/reference/compiler/iteratorIncludes.errors.txt new file mode 100644 index 0000000000000..31de09d8bc8e0 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorIncludes.errors.txt @@ -0,0 +1,16 @@ +iteratorIncludes.ts(4,35): error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'. +iteratorIncludes.ts(6,38): error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'. + + +==== iteratorIncludes.ts (2 errors) ==== + const includes: boolean = Iterator.from([1, 2, 3]).includes(2); + const includesAfterSkipping: boolean = Iterator.from([1, 2, 3]).includes(2, 1); + + Iterator.from([1, 2, 3]).includes("1"); + ~~~ +!!! error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'. + + Iterator.from([1, 2, 3]).includes(2, "1"); + ~~~ +!!! error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/iteratorIncludes.js b/tsc/testdata/baselines/reference/compiler/iteratorIncludes.js index 1ea356fb40321..92d42f4785296 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorIncludes.js +++ b/tsc/testdata/baselines/reference/compiler/iteratorIncludes.js @@ -4,10 +4,8 @@ const includes: boolean = Iterator.from([1, 2, 3]).includes(2); const includesAfterSkipping: boolean = Iterator.from([1, 2, 3]).includes(2, 1); -// @ts-expect-error the searched value must match the iterator value Iterator.from([1, 2, 3]).includes("1"); -// @ts-expect-error skipped elements must be a number Iterator.from([1, 2, 3]).includes(2, "1"); @@ -15,7 +13,5 @@ Iterator.from([1, 2, 3]).includes(2, "1"); "use strict"; const includes = Iterator.from([1, 2, 3]).includes(2); const includesAfterSkipping = Iterator.from([1, 2, 3]).includes(2, 1); -// @ts-expect-error the searched value must match the iterator value Iterator.from([1, 2, 3]).includes("1"); -// @ts-expect-error skipped elements must be a number Iterator.from([1, 2, 3]).includes(2, "1"); diff --git a/tsc/testdata/baselines/reference/compiler/iteratorIncludes.symbols b/tsc/testdata/baselines/reference/compiler/iteratorIncludes.symbols index 0b1fc3aa3aa5d..e1d0affa5aa76 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorIncludes.symbols +++ b/tsc/testdata/baselines/reference/compiler/iteratorIncludes.symbols @@ -17,7 +17,6 @@ const includesAfterSkipping: boolean = Iterator.from([1, 2, 3]).includes(2, 1); >from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) >includes : Symbol(IteratorObject.includes, Decl(lib.esnext.iterator.d.ts, --, --)) -// @ts-expect-error the searched value must match the iterator value Iterator.from([1, 2, 3]).includes("1"); >Iterator.from([1, 2, 3]).includes : Symbol(IteratorObject.includes, Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator.from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) @@ -25,7 +24,6 @@ Iterator.from([1, 2, 3]).includes("1"); >from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) >includes : Symbol(IteratorObject.includes, Decl(lib.esnext.iterator.d.ts, --, --)) -// @ts-expect-error skipped elements must be a number Iterator.from([1, 2, 3]).includes(2, "1"); >Iterator.from([1, 2, 3]).includes : Symbol(IteratorObject.includes, Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator.from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) diff --git a/tsc/testdata/baselines/reference/compiler/iteratorIncludes.types b/tsc/testdata/baselines/reference/compiler/iteratorIncludes.types index 66bfdd1da6992..9883553132cea 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorIncludes.types +++ b/tsc/testdata/baselines/reference/compiler/iteratorIncludes.types @@ -32,7 +32,6 @@ const includesAfterSkipping: boolean = Iterator.from([1, 2, 3]).includes(2, 1); >2 : 2 >1 : 1 -// @ts-expect-error the searched value must match the iterator value Iterator.from([1, 2, 3]).includes("1"); >Iterator.from([1, 2, 3]).includes("1") : boolean >Iterator.from([1, 2, 3]).includes : (searchElement: number, skippedElements?: number) => boolean @@ -47,7 +46,6 @@ Iterator.from([1, 2, 3]).includes("1"); >includes : (searchElement: number, skippedElements?: number) => boolean >"1" : "1" -// @ts-expect-error skipped elements must be a number Iterator.from([1, 2, 3]).includes(2, "1"); >Iterator.from([1, 2, 3]).includes(2, "1") : boolean >Iterator.from([1, 2, 3]).includes : (searchElement: number, skippedElements?: number) => boolean diff --git a/tsc/testdata/baselines/reference/compiler/iteratorJoin.errors.txt b/tsc/testdata/baselines/reference/compiler/iteratorJoin.errors.txt new file mode 100644 index 0000000000000..b0f965b138061 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorJoin.errors.txt @@ -0,0 +1,11 @@ +iteratorJoin.ts(4,31): error TS2345: Argument of type 'number' is not assignable to parameter of type 'string'. + + +==== iteratorJoin.ts (1 errors) ==== + const joined: string = Iterator.from([1, 2, 3]).join("-"); + const joinedWithDefaultSeparator: string = Iterator.from([1, 2, 3]).join(); + + Iterator.from([1, 2, 3]).join(0); + ~ +!!! error TS2345: Argument of type 'number' is not assignable to parameter of type 'string'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/iteratorJoin.js b/tsc/testdata/baselines/reference/compiler/iteratorJoin.js index 2d8983a916905..128b43c5b193d 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorJoin.js +++ b/tsc/testdata/baselines/reference/compiler/iteratorJoin.js @@ -4,7 +4,6 @@ const joined: string = Iterator.from([1, 2, 3]).join("-"); const joinedWithDefaultSeparator: string = Iterator.from([1, 2, 3]).join(); -// @ts-expect-error separator must be a string Iterator.from([1, 2, 3]).join(0); @@ -12,5 +11,4 @@ Iterator.from([1, 2, 3]).join(0); "use strict"; const joined = Iterator.from([1, 2, 3]).join("-"); const joinedWithDefaultSeparator = Iterator.from([1, 2, 3]).join(); -// @ts-expect-error separator must be a string Iterator.from([1, 2, 3]).join(0); diff --git a/tsc/testdata/baselines/reference/compiler/iteratorJoin.symbols b/tsc/testdata/baselines/reference/compiler/iteratorJoin.symbols index d004fb3482b46..94c7ac9cbd5c1 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorJoin.symbols +++ b/tsc/testdata/baselines/reference/compiler/iteratorJoin.symbols @@ -17,7 +17,6 @@ const joinedWithDefaultSeparator: string = Iterator.from([1, 2, 3]).join(); >from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) >join : Symbol(IteratorObject.join, Decl(lib.esnext.iterator.d.ts, --, --)) -// @ts-expect-error separator must be a string Iterator.from([1, 2, 3]).join(0); >Iterator.from([1, 2, 3]).join : Symbol(IteratorObject.join, Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator.from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) diff --git a/tsc/testdata/baselines/reference/compiler/iteratorJoin.types b/tsc/testdata/baselines/reference/compiler/iteratorJoin.types index 55ed9784d2056..cad93dd3c8210 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorJoin.types +++ b/tsc/testdata/baselines/reference/compiler/iteratorJoin.types @@ -30,7 +30,6 @@ const joinedWithDefaultSeparator: string = Iterator.from([1, 2, 3]).join(); >3 : 3 >join : (separator?: string) => string -// @ts-expect-error separator must be a string Iterator.from([1, 2, 3]).join(0); >Iterator.from([1, 2, 3]).join(0) : string >Iterator.from([1, 2, 3]).join : (separator?: string) => string diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip.errors.txt b/tsc/testdata/baselines/reference/compiler/iteratorZip.errors.txt new file mode 100644 index 0000000000000..a0d14c8d721a6 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorZip.errors.txt @@ -0,0 +1,120 @@ +iteratorZip.ts(62,23): error TS2769: No overload matches this call. + The last overload gave the following error. + Type '"invalid"' is not assignable to type '"longest" | "shortest" | "strict" | undefined'. +iteratorZip.ts(64,56): error TS2769: No overload matches this call. + The last overload gave the following error. + Type 'true[]' is not assignable to type 'Iterable<"a" | 1>'. + The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. + Type 'IteratorResult' is not assignable to type 'IteratorResult<"a" | 1, any>'. + Type 'IteratorYieldResult' is not assignable to type 'IteratorResult<"a" | 1, any>'. + Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult<"a" | 1>'. + Type 'true' is not assignable to type '"a" | 1'. +iteratorZip.ts(66,41): error TS2769: No overload matches this call. + The last overload gave the following error. + Object literal may only specify known properties, and 'padding' does not exist in type 'IteratorZipShortestOptions'. +iteratorZip.ts(68,14): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type 'number' is not assignable to parameter of type 'Iterable>'. +iteratorZip.ts(70,21): error TS2322: Type 'number' is not assignable to type 'number & IteratorInput'. + + +==== iteratorZip.ts (5 errors) ==== + declare const key: unique symbol; + + const tuples: [number, string][] = Iterator.zip([ + [1, 2], + new Set(["a", "b"]), + ] as const).toArray(); + + tuples[0][0] = 2; + + const shortestTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray(); + const strictTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray(); + const longestTuplesWithPadding: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray(); + const longestTuplesWithoutPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray(); + const longestTuplesWithPartialPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray(); + + declare const maybeLongestOptions: { mode: "shortest"; } | { mode: "longest"; }; + const maybeLongestTuples: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray(); + + const empty: never[] = Iterator.zip([]).toArray(); + const emptyLongest: never[] = Iterator.zip([], { mode: "longest" }).toArray(); + + declare const iterables: Iterable>; + const arrays: number[][] = Iterator.zip(iterables).toArray(); + const longestArrays: (number | undefined)[][] = Iterator.zip(iterables, { mode: "longest" }).toArray(); + const maybeLongestArrays: (number | undefined)[][] = Iterator.zip(iterables, maybeLongestOptions).toArray(); + + declare const iterableArray: Iterable[]; + const longestArrayWithPadding: (number | undefined)[][] = Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray(); + + const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ + a: [1, 2], + b: new Set(["a", "b"]), + [key]: [true, false], + } as const).toArray(); + + objects[0].a = 2; + + const longestObjectsWithPadding: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { + mode: "longest", + padding: { a: 1, b: "a" }, + }).toArray(); + + const longestObjectsWithoutPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { + mode: "longest", + }).toArray(); + + const longestObjectsWithPartialPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { + mode: "longest", + padding: { b: "a" }, + }).toArray(); + + const maybeLongestObjects: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray(); + + interface Inputs { + a: Iterable; + b: Iterator; + } + + declare const inputs: Inputs; + const rows: { a: number; b: string; }[] = Iterator.zipKeyed(inputs).toArray(); + + Iterator.zip([[1]], { mode: "invalid" }); + ~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Type '"invalid"' is not assignable to type '"longest" | "shortest" | "strict" | undefined'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + + Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }); + ~~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Type 'true[]' is not assignable to type 'Iterable<"a" | 1>'. +!!! error TS2769: The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. +!!! error TS2769: Type 'IteratorResult' is not assignable to type 'IteratorResult<"a" | 1, any>'. +!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorResult<"a" | 1, any>'. +!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult<"a" | 1>'. +!!! error TS2769: Type 'true' is not assignable to type '"a" | 1'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + + Iterator.zip([[1]], { mode: "shortest", padding: [1] }); + ~~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Object literal may only specify known properties, and 'padding' does not exist in type 'IteratorZipShortestOptions'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + + Iterator.zip(0); + ~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type 'number' is not assignable to parameter of type 'Iterable>'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + + Iterator.zipKeyed({ a: 0 }); + ~ +!!! error TS2322: Type 'number' is not assignable to type 'number & IteratorInput'. +!!! related TS6500 iteratorZip.ts:70:21: The expected type comes from property 'a' which is declared here on type '{ a: number; } & Record<"a", IteratorInput>' + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip.js b/tsc/testdata/baselines/reference/compiler/iteratorZip.js index 5148a43bc92c2..ea5e813d79631 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorZip.js +++ b/tsc/testdata/baselines/reference/compiler/iteratorZip.js @@ -10,14 +10,25 @@ const tuples: [number, string][] = Iterator.zip([ tuples[0][0] = 2; -Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }); -Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }); -Iterator.zip([[1], ["a"]] as const, { mode: "strict" }); +const shortestTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray(); +const strictTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray(); +const longestTuplesWithPadding: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray(); +const longestTuplesWithoutPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray(); +const longestTuplesWithPartialPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray(); + +declare const maybeLongestOptions: { mode: "shortest"; } | { mode: "longest"; }; +const maybeLongestTuples: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray(); const empty: never[] = Iterator.zip([]).toArray(); +const emptyLongest: never[] = Iterator.zip([], { mode: "longest" }).toArray(); declare const iterables: Iterable>; const arrays: number[][] = Iterator.zip(iterables).toArray(); +const longestArrays: (number | undefined)[][] = Iterator.zip(iterables, { mode: "longest" }).toArray(); +const maybeLongestArrays: (number | undefined)[][] = Iterator.zip(iterables, maybeLongestOptions).toArray(); + +declare const iterableArray: Iterable[]; +const longestArrayWithPadding: (number | undefined)[][] = Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray(); const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ a: [1, 2], @@ -27,10 +38,21 @@ const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ objects[0].a = 2; -Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +const longestObjectsWithPadding: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { + mode: "longest", + padding: { a: 1, b: "a" }, +}).toArray(); + +const longestObjectsWithoutPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { + mode: "longest", +}).toArray(); + +const longestObjectsWithPartialPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" }, -}); +}).toArray(); + +const maybeLongestObjects: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray(); interface Inputs { a: Iterable; @@ -40,19 +62,14 @@ interface Inputs { declare const inputs: Inputs; const rows: { a: number; b: string; }[] = Iterator.zipKeyed(inputs).toArray(); -// @ts-expect-error invalid mode Iterator.zip([[1]], { mode: "invalid" }); -// @ts-expect-error padding values must match the input element types Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }); -// @ts-expect-error padding is only used in longest mode Iterator.zip([[1]], { mode: "shortest", padding: [1] }); -// @ts-expect-error the input must be iterable Iterator.zip(0); -// @ts-expect-error each keyed value must be iterable Iterator.zipKeyed({ a: 0 }); @@ -63,29 +80,39 @@ const tuples = Iterator.zip([ new Set(["a", "b"]), ]).toArray(); tuples[0][0] = 2; -Iterator.zip([[1], ["a"]], { mode: "shortest" }); -Iterator.zip([[1], ["a"]], { mode: "longest", padding: [1] }); -Iterator.zip([[1], ["a"]], { mode: "strict" }); +const shortestTuples = Iterator.zip([[1], ["a"]], { mode: "shortest" }).toArray(); +const strictTuples = Iterator.zip([[1], ["a"]], { mode: "strict" }).toArray(); +const longestTuplesWithPadding = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [1, "a"] }).toArray(); +const longestTuplesWithoutPadding = Iterator.zip([[1], ["a"]], { mode: "longest" }).toArray(); +const longestTuplesWithPartialPadding = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [1] }).toArray(); +const maybeLongestTuples = Iterator.zip([[1], ["a"]], maybeLongestOptions).toArray(); const empty = Iterator.zip([]).toArray(); +const emptyLongest = Iterator.zip([], { mode: "longest" }).toArray(); const arrays = Iterator.zip(iterables).toArray(); +const longestArrays = Iterator.zip(iterables, { mode: "longest" }).toArray(); +const maybeLongestArrays = Iterator.zip(iterables, maybeLongestOptions).toArray(); +const longestArrayWithPadding = Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray(); const objects = Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false], }).toArray(); objects[0].a = 2; -Iterator.zipKeyed({ a: [1], b: ["a"] }, { +const longestObjectsWithPadding = Iterator.zipKeyed({ a: [1], b: ["a"] }, { + mode: "longest", + padding: { a: 1, b: "a" }, +}).toArray(); +const longestObjectsWithoutPadding = Iterator.zipKeyed({ a: [1], b: ["a"] }, { + mode: "longest", +}).toArray(); +const longestObjectsWithPartialPadding = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { b: "a" }, -}); +}).toArray(); +const maybeLongestObjects = Iterator.zipKeyed({ a: [1], b: ["a"] }, maybeLongestOptions).toArray(); const rows = Iterator.zipKeyed(inputs).toArray(); -// @ts-expect-error invalid mode Iterator.zip([[1]], { mode: "invalid" }); -// @ts-expect-error padding values must match the input element types Iterator.zip([[1], ["a"]], { mode: "longest", padding: [true] }); -// @ts-expect-error padding is only used in longest mode Iterator.zip([[1]], { mode: "shortest", padding: [1] }); -// @ts-expect-error the input must be iterable Iterator.zip(0); -// @ts-expect-error each keyed value must be iterable Iterator.zipKeyed({ a: 0 }); diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip.symbols b/tsc/testdata/baselines/reference/compiler/iteratorZip.symbols index 8ac41ad65154a..c427139883826 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorZip.symbols +++ b/tsc/testdata/baselines/reference/compiler/iteratorZip.symbols @@ -7,9 +7,9 @@ declare const key: unique symbol; const tuples: [number, string][] = Iterator.zip([ >tuples : Symbol(tuples, Decl(iteratorZip.ts, 2, 5)) >Iterator.zip([ [1, 2], new Set(["a", "b"]),] as const).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) [1, 2], new Set(["a", "b"]), @@ -23,70 +23,159 @@ tuples[0][0] = 2; >tuples : Symbol(tuples, Decl(iteratorZip.ts, 2, 5)) >0 : Symbol(0) -Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }); ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +const shortestTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray(); +>shortestTuples : Symbol(shortestTuples, Decl(iteratorZip.ts, 9, 5)) +>Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >const : Symbol(const) ->mode : Symbol(mode, Decl(iteratorZip.ts, 9, 37)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 9, 80)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }); ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +const strictTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray(); +>strictTuples : Symbol(strictTuples, Decl(iteratorZip.ts, 10, 5)) +>Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >const : Symbol(const) ->mode : Symbol(mode, Decl(iteratorZip.ts, 10, 37)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 10, 54)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 10, 78)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -Iterator.zip([[1], ["a"]] as const, { mode: "strict" }); ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +const longestTuplesWithPadding: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray(); +>longestTuplesWithPadding : Symbol(longestTuplesWithPadding, Decl(iteratorZip.ts, 11, 5)) +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >const : Symbol(const) ->mode : Symbol(mode, Decl(iteratorZip.ts, 11, 37)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 11, 90)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 11, 107)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const longestTuplesWithoutPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray(); +>longestTuplesWithoutPadding : Symbol(longestTuplesWithoutPadding, Decl(iteratorZip.ts, 12, 5)) +>Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>const : Symbol(const) +>mode : Symbol(mode, Decl(iteratorZip.ts, 12, 117)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const longestTuplesWithPartialPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray(); +>longestTuplesWithPartialPadding : Symbol(longestTuplesWithPartialPadding, Decl(iteratorZip.ts, 13, 5)) +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>const : Symbol(const) +>mode : Symbol(mode, Decl(iteratorZip.ts, 13, 121)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 13, 138)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const maybeLongestOptions: { mode: "shortest"; } | { mode: "longest"; }; +>maybeLongestOptions : Symbol(maybeLongestOptions, Decl(iteratorZip.ts, 15, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 15, 36)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 15, 60)) + +const maybeLongestTuples: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray(); +>maybeLongestTuples : Symbol(maybeLongestTuples, Decl(iteratorZip.ts, 16, 5)) +>Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>const : Symbol(const) +>maybeLongestOptions : Symbol(maybeLongestOptions, Decl(iteratorZip.ts, 15, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const empty: never[] = Iterator.zip([]).toArray(); ->empty : Symbol(empty, Decl(iteratorZip.ts, 13, 5)) +>empty : Symbol(empty, Decl(iteratorZip.ts, 18, 5)) >Iterator.zip([]).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const emptyLongest: never[] = Iterator.zip([], { mode: "longest" }).toArray(); +>emptyLongest : Symbol(emptyLongest, Decl(iteratorZip.ts, 19, 5)) +>Iterator.zip([], { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZip.ts, 19, 48)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) declare const iterables: Iterable>; ->iterables : Symbol(iterables, Decl(iteratorZip.ts, 15, 13)) +>iterables : Symbol(iterables, Decl(iteratorZip.ts, 21, 13)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) const arrays: number[][] = Iterator.zip(iterables).toArray(); ->arrays : Symbol(arrays, Decl(iteratorZip.ts, 16, 5)) +>arrays : Symbol(arrays, Decl(iteratorZip.ts, 22, 5)) >Iterator.zip(iterables).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>iterables : Symbol(iterables, Decl(iteratorZip.ts, 21, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const longestArrays: (number | undefined)[][] = Iterator.zip(iterables, { mode: "longest" }).toArray(); +>longestArrays : Symbol(longestArrays, Decl(iteratorZip.ts, 23, 5)) +>Iterator.zip(iterables, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>iterables : Symbol(iterables, Decl(iteratorZip.ts, 21, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 23, 73)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const maybeLongestArrays: (number | undefined)[][] = Iterator.zip(iterables, maybeLongestOptions).toArray(); +>maybeLongestArrays : Symbol(maybeLongestArrays, Decl(iteratorZip.ts, 24, 5)) +>Iterator.zip(iterables, maybeLongestOptions).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->iterables : Symbol(iterables, Decl(iteratorZip.ts, 15, 13)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>iterables : Symbol(iterables, Decl(iteratorZip.ts, 21, 13)) +>maybeLongestOptions : Symbol(maybeLongestOptions, Decl(iteratorZip.ts, 15, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const iterableArray: Iterable[]; +>iterableArray : Symbol(iterableArray, Decl(iteratorZip.ts, 26, 13)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + +const longestArrayWithPadding: (number | undefined)[][] = Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray(); +>longestArrayWithPadding : Symbol(longestArrayWithPadding, Decl(iteratorZip.ts, 27, 5)) +>Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>iterableArray : Symbol(iterableArray, Decl(iteratorZip.ts, 26, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 27, 87)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 27, 104)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ ->objects : Symbol(objects, Decl(iteratorZip.ts, 18, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 18, 16)) ->b : Symbol(b, Decl(iteratorZip.ts, 18, 27)) ->[key] : Symbol([key], Decl(iteratorZip.ts, 18, 38)) +>objects : Symbol(objects, Decl(iteratorZip.ts, 29, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 29, 16)) +>b : Symbol(b, Decl(iteratorZip.ts, 29, 27)) +>[key] : Symbol([key], Decl(iteratorZip.ts, 29, 38)) >key : Symbol(key, Decl(iteratorZip.ts, 0, 13)) >Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) a: [1, 2], ->a : Symbol(a, Decl(iteratorZip.ts, 18, 80)) +>a : Symbol(a, Decl(iteratorZip.ts, 29, 80)) b: new Set(["a", "b"]), ->b : Symbol(b, Decl(iteratorZip.ts, 19, 14)) +>b : Symbol(b, Decl(iteratorZip.ts, 30, 14)) >Set : Symbol(Set, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) [key]: [true, false], ->[key] : Symbol([key], Decl(iteratorZip.ts, 20, 27)) +>[key] : Symbol([key], Decl(iteratorZip.ts, 31, 27)) >key : Symbol(key, Decl(iteratorZip.ts, 0, 13)) } as const).toArray(); @@ -94,88 +183,143 @@ const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) objects[0].a = 2; ->objects[0].a : Symbol(a, Decl(iteratorZip.ts, 18, 16)) ->objects : Symbol(objects, Decl(iteratorZip.ts, 18, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 18, 16)) +>objects[0].a : Symbol(a, Decl(iteratorZip.ts, 29, 16)) +>objects : Symbol(objects, Decl(iteratorZip.ts, 29, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 29, 16)) + +const longestObjectsWithPadding: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +>longestObjectsWithPadding : Symbol(longestObjectsWithPadding, Decl(iteratorZip.ts, 37, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 37, 34)) +>b : Symbol(b, Decl(iteratorZip.ts, 37, 45)) +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 37, 82)) +>b : Symbol(b, Decl(iteratorZip.ts, 37, 90)) +>const : Symbol(const) + + mode: "longest", +>mode : Symbol(mode, Decl(iteratorZip.ts, 37, 113)) + + padding: { a: 1, b: "a" }, +>padding : Symbol(padding, Decl(iteratorZip.ts, 38, 20)) +>a : Symbol(a, Decl(iteratorZip.ts, 39, 14)) +>b : Symbol(b, Decl(iteratorZip.ts, 39, 20)) + +}).toArray(); +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --)) +const longestObjectsWithoutPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +>longestObjectsWithoutPadding : Symbol(longestObjectsWithoutPadding, Decl(iteratorZip.ts, 42, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 42, 37)) +>b : Symbol(b, Decl(iteratorZip.ts, 42, 60)) +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 26, 19)) ->b : Symbol(b, Decl(iteratorZip.ts, 26, 27)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 42, 109)) +>b : Symbol(b, Decl(iteratorZip.ts, 42, 117)) >const : Symbol(const) mode: "longest", ->mode : Symbol(mode, Decl(iteratorZip.ts, 26, 50)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 42, 140)) + +}).toArray(); +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const longestObjectsWithPartialPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +>longestObjectsWithPartialPadding : Symbol(longestObjectsWithPartialPadding, Decl(iteratorZip.ts, 46, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 46, 41)) +>b : Symbol(b, Decl(iteratorZip.ts, 46, 64)) +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 46, 113)) +>b : Symbol(b, Decl(iteratorZip.ts, 46, 121)) +>const : Symbol(const) + + mode: "longest", +>mode : Symbol(mode, Decl(iteratorZip.ts, 46, 144)) padding: { b: "a" }, ->padding : Symbol(padding, Decl(iteratorZip.ts, 27, 20)) ->b : Symbol(b, Decl(iteratorZip.ts, 28, 14)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 47, 20)) +>b : Symbol(b, Decl(iteratorZip.ts, 48, 14)) + +}).toArray(); +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -}); +const maybeLongestObjects: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray(); +>maybeLongestObjects : Symbol(maybeLongestObjects, Decl(iteratorZip.ts, 51, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 51, 28)) +>b : Symbol(b, Decl(iteratorZip.ts, 51, 51)) +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 51, 100)) +>b : Symbol(b, Decl(iteratorZip.ts, 51, 108)) +>const : Symbol(const) +>maybeLongestOptions : Symbol(maybeLongestOptions, Decl(iteratorZip.ts, 15, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) interface Inputs { ->Inputs : Symbol(Inputs, Decl(iteratorZip.ts, 29, 3)) +>Inputs : Symbol(Inputs, Decl(iteratorZip.ts, 51, 161)) a: Iterable; ->a : Symbol(Inputs.a, Decl(iteratorZip.ts, 31, 18)) +>a : Symbol(Inputs.a, Decl(iteratorZip.ts, 53, 18)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) b: Iterator; ->b : Symbol(Inputs.b, Decl(iteratorZip.ts, 32, 24)) +>b : Symbol(Inputs.b, Decl(iteratorZip.ts, 54, 24)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) } declare const inputs: Inputs; ->inputs : Symbol(inputs, Decl(iteratorZip.ts, 36, 13)) ->Inputs : Symbol(Inputs, Decl(iteratorZip.ts, 29, 3)) +>inputs : Symbol(inputs, Decl(iteratorZip.ts, 58, 13)) +>Inputs : Symbol(Inputs, Decl(iteratorZip.ts, 51, 161)) const rows: { a: number; b: string; }[] = Iterator.zipKeyed(inputs).toArray(); ->rows : Symbol(rows, Decl(iteratorZip.ts, 37, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 37, 13)) ->b : Symbol(b, Decl(iteratorZip.ts, 37, 24)) +>rows : Symbol(rows, Decl(iteratorZip.ts, 59, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 59, 13)) +>b : Symbol(b, Decl(iteratorZip.ts, 59, 24)) >Iterator.zipKeyed(inputs).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --)) ->inputs : Symbol(inputs, Decl(iteratorZip.ts, 36, 13)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>inputs : Symbol(inputs, Decl(iteratorZip.ts, 58, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -// @ts-expect-error invalid mode Iterator.zip([[1]], { mode: "invalid" }); ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 40, 21)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZip.ts, 61, 21)) -// @ts-expect-error padding values must match the input element types Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }); ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >const : Symbol(const) ->mode : Symbol(mode, Decl(iteratorZip.ts, 43, 37)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 43, 54)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 63, 37)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 63, 54)) -// @ts-expect-error padding is only used in longest mode Iterator.zip([[1]], { mode: "shortest", padding: [1] }); ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 46, 21)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 46, 39)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZip.ts, 65, 21)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 65, 39)) -// @ts-expect-error the input must be iterable Iterator.zip(0); ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) -// @ts-expect-error each keyed value must be iterable Iterator.zipKeyed({ a: 0 }); ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 52, 19)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 69, 19)) diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip.types b/tsc/testdata/baselines/reference/compiler/iteratorZip.types index 0ee4392d2b4ef..3b6109820c9b3 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorZip.types +++ b/tsc/testdata/baselines/reference/compiler/iteratorZip.types @@ -9,9 +9,9 @@ const tuples: [number, string][] = Iterator.zip([ >Iterator.zip([ [1, 2], new Set(["a", "b"]),] as const).toArray() : [1 | 2, string][] >Iterator.zip([ [1, 2], new Set(["a", "b"]),] as const).toArray : () => [1 | 2, string][] >Iterator.zip([ [1, 2], new Set(["a", "b"]),] as const) : IteratorObject<[1 | 2, string], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } >[ [1, 2], new Set(["a", "b"]),] as const : [readonly [1, 2], Set] >[ [1, 2], new Set(["a", "b"]),] : [readonly [1, 2], Set] @@ -39,11 +39,14 @@ tuples[0][0] = 2; >0 : 0 >2 : 2 -Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }); +const shortestTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray(); +>shortestTuples : [number, string][] +>Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray() : [1, "a"][] +>Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray : () => [1, "a"][] >Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }) : IteratorObject<[1, "a"], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } >[[1], ["a"]] as const : [readonly [1], readonly ["a"]] >[[1], ["a"]] : [readonly [1], readonly ["a"]] >[1] : readonly [1] @@ -53,12 +56,77 @@ Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }); >{ mode: "shortest" } : { mode: "shortest"; } >mode : "shortest" >"shortest" : "shortest" +>toArray : () => [1, "a"][] -Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }); ->Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }) : IteratorObject<[1, "a"], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +const strictTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray(); +>strictTuples : [number, string][] +>Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray() : [1, "a"][] +>Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray : () => [1, "a"][] +>Iterator.zip([[1], ["a"]] as const, { mode: "strict" }) : IteratorObject<[1, "a"], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] as const : [readonly [1], readonly ["a"]] +>[[1], ["a"]] : [readonly [1], readonly ["a"]] +>[1] : readonly [1] +>1 : 1 +>["a"] : readonly ["a"] +>"a" : "a" +>{ mode: "strict" } : { mode: "strict"; } +>mode : "strict" +>"strict" : "strict" +>toArray : () => [1, "a"][] + +const longestTuplesWithPadding: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray(); +>longestTuplesWithPadding : [number, string][] +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray() : [1, "a"][] +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray : () => [1, "a"][] +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }) : IteratorObject<[1, "a"], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] as const : readonly [readonly [1], readonly ["a"]] +>[[1], ["a"]] : readonly [readonly [1], readonly ["a"]] +>[1] : readonly [1] +>1 : 1 +>["a"] : readonly ["a"] +>"a" : "a" +>{ mode: "longest", padding: [1, "a"] } : { mode: "longest"; padding: [1, "a"]; } +>mode : "longest" +>"longest" : "longest" +>padding : [1, "a"] +>[1, "a"] : [1, "a"] +>1 : 1 +>"a" : "a" +>toArray : () => [1, "a"][] + +const longestTuplesWithoutPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray(); +>longestTuplesWithoutPadding : [number | undefined, string | undefined][] +>Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray() : [1 | undefined, "a" | undefined][] +>Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray : () => [1 | undefined, "a" | undefined][] +>Iterator.zip([[1], ["a"]] as const, { mode: "longest" }) : IteratorObject<[1 | undefined, "a" | undefined], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] as const : [readonly [1], readonly ["a"]] +>[[1], ["a"]] : [readonly [1], readonly ["a"]] +>[1] : readonly [1] +>1 : 1 +>["a"] : readonly ["a"] +>"a" : "a" +>{ mode: "longest" } : { mode: "longest"; } +>mode : "longest" +>"longest" : "longest" +>toArray : () => [1 | undefined, "a" | undefined][] + +const longestTuplesWithPartialPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray(); +>longestTuplesWithPartialPadding : [number | undefined, string | undefined][] +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray() : [1 | undefined, "a" | undefined][] +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray : () => [1 | undefined, "a" | undefined][] +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }) : IteratorObject<[1 | undefined, "a" | undefined], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } >[[1], ["a"]] as const : [readonly [1], readonly ["a"]] >[[1], ["a"]] : [readonly [1], readonly ["a"]] >[1] : readonly [1] @@ -71,31 +139,53 @@ Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }); >padding : [1] >[1] : [1] >1 : 1 +>toArray : () => [1 | undefined, "a" | undefined][] -Iterator.zip([[1], ["a"]] as const, { mode: "strict" }); ->Iterator.zip([[1], ["a"]] as const, { mode: "strict" }) : IteratorObject<[1, "a"], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +declare const maybeLongestOptions: { mode: "shortest"; } | { mode: "longest"; }; +>maybeLongestOptions : { mode: "shortest"; } | { mode: "longest"; } +>mode : "shortest" +>mode : "longest" + +const maybeLongestTuples: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray(); +>maybeLongestTuples : [number | undefined, string | undefined][] +>Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray() : [1 | undefined, "a" | undefined][] +>Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray : () => [1 | undefined, "a" | undefined][] +>Iterator.zip([[1], ["a"]] as const, maybeLongestOptions) : IteratorObject<[1 | undefined, "a" | undefined], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } >[[1], ["a"]] as const : [readonly [1], readonly ["a"]] >[[1], ["a"]] : [readonly [1], readonly ["a"]] >[1] : readonly [1] >1 : 1 >["a"] : readonly ["a"] >"a" : "a" ->{ mode: "strict" } : { mode: "strict"; } ->mode : "strict" ->"strict" : "strict" +>maybeLongestOptions : { mode: "shortest"; } | { mode: "longest"; } +>toArray : () => [1 | undefined, "a" | undefined][] const empty: never[] = Iterator.zip([]).toArray(); >empty : never[] >Iterator.zip([]).toArray() : never[] >Iterator.zip([]).toArray : () => never[] >Iterator.zip([]) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>[] : [] +>toArray : () => never[] + +const emptyLongest: never[] = Iterator.zip([], { mode: "longest" }).toArray(); +>emptyLongest : never[] +>Iterator.zip([], { mode: "longest" }).toArray() : never[] +>Iterator.zip([], { mode: "longest" }).toArray : () => never[] +>Iterator.zip([], { mode: "longest" }) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } >[] : [] +>{ mode: "longest" } : { mode: "longest"; } +>mode : "longest" +>"longest" : "longest" >toArray : () => never[] declare const iterables: Iterable>; @@ -106,12 +196,57 @@ const arrays: number[][] = Iterator.zip(iterables).toArray(); >Iterator.zip(iterables).toArray() : number[][] >Iterator.zip(iterables).toArray : () => number[][] >Iterator.zip(iterables) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } >iterables : Iterable> >toArray : () => number[][] +const longestArrays: (number | undefined)[][] = Iterator.zip(iterables, { mode: "longest" }).toArray(); +>longestArrays : (number | undefined)[][] +>Iterator.zip(iterables, { mode: "longest" }).toArray() : (number | undefined)[][] +>Iterator.zip(iterables, { mode: "longest" }).toArray : () => (number | undefined)[][] +>Iterator.zip(iterables, { mode: "longest" }) : IteratorObject<(number | undefined)[], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>iterables : Iterable> +>{ mode: "longest" } : { mode: "longest"; } +>mode : "longest" +>"longest" : "longest" +>toArray : () => (number | undefined)[][] + +const maybeLongestArrays: (number | undefined)[][] = Iterator.zip(iterables, maybeLongestOptions).toArray(); +>maybeLongestArrays : (number | undefined)[][] +>Iterator.zip(iterables, maybeLongestOptions).toArray() : (number | undefined)[][] +>Iterator.zip(iterables, maybeLongestOptions).toArray : () => (number | undefined)[][] +>Iterator.zip(iterables, maybeLongestOptions) : IteratorObject<(number | undefined)[], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>iterables : Iterable> +>maybeLongestOptions : { mode: "shortest"; } | { mode: "longest"; } +>toArray : () => (number | undefined)[][] + +declare const iterableArray: Iterable[]; +>iterableArray : Iterable[] + +const longestArrayWithPadding: (number | undefined)[][] = Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray(); +>longestArrayWithPadding : (number | undefined)[][] +>Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray() : (number | undefined)[][] +>Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray : () => (number | undefined)[][] +>Iterator.zip(iterableArray, { mode: "longest", padding: [] }) : IteratorObject<(number | undefined)[], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>iterableArray : Iterable[] +>{ mode: "longest", padding: [] } : { mode: "longest"; padding: never[]; } +>mode : "longest" +>"longest" : "longest" +>padding : never[] +>[] : never[] +>toArray : () => (number | undefined)[][] + const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ >objects : { a: number; b: string; [key]: boolean; }[] >a : number @@ -121,9 +256,9 @@ const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ >Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const).toArray() : { a: 1 | 2; b: string; [key]: boolean; }[] >Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const).toArray : () => { a: 1 | 2; b: string; [key]: boolean; }[] >Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const) : IteratorObject<{ a: 1 | 2; b: string; [key]: boolean; }, undefined, unknown> ->Iterator.zipKeyed : | Iterator; }>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined) => IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : | Iterator; }>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined) => IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown> +>zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; } >{ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const : { readonly a: readonly [1, 2]; readonly b: Set; readonly [key]: readonly [true, false]; } >{ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} : { readonly a: readonly [1, 2]; readonly b: Set; readonly [key]: readonly [true, false]; } @@ -160,11 +295,78 @@ objects[0].a = 2; >a : number >2 : 2 -Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}) : IteratorObject<{ a: 1; b: "a"; }, undefined, unknown> ->Iterator.zipKeyed : | Iterator; }>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined) => IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown> +const longestObjectsWithPadding: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +>longestObjectsWithPadding : { a: number; b: string; }[] +>a : number +>b : string +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}).toArray() : { a: 1; b: "a"; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}).toArray : () => { a: 1; b: "a"; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}) : IteratorObject<{ a: 1; b: "a"; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; } +>{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } +>{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } +>a : readonly [1] +>[1] : readonly [1] +>1 : 1 +>b : readonly ["a"] +>["a"] : readonly ["a"] +>"a" : "a" +>{ mode: "longest", padding: { a: 1, b: "a" },} : { mode: "longest"; padding: { a: 1; b: "a"; }; } + + mode: "longest", +>mode : "longest" +>"longest" : "longest" + + padding: { a: 1, b: "a" }, +>padding : { a: 1; b: "a"; } +>{ a: 1, b: "a" } : { a: 1; b: "a"; } +>a : 1 +>1 : 1 +>b : "a" +>"a" : "a" + +}).toArray(); +>toArray : () => { a: 1; b: "a"; }[] + +const longestObjectsWithoutPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +>longestObjectsWithoutPadding : { a: number | undefined; b: string | undefined; }[] +>a : number | undefined +>b : string | undefined +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}).toArray() : { a: 1 | undefined; b: "a" | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}).toArray : () => { a: 1 | undefined; b: "a" | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}) : IteratorObject<{ a: 1 | undefined; b: "a" | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; } +>{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } +>{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } +>a : readonly [1] +>[1] : readonly [1] +>1 : 1 +>b : readonly ["a"] +>["a"] : readonly ["a"] +>"a" : "a" +>{ mode: "longest",} : { mode: "longest"; } + + mode: "longest", +>mode : "longest" +>"longest" : "longest" + +}).toArray(); +>toArray : () => { a: 1 | undefined; b: "a" | undefined; }[] + +const longestObjectsWithPartialPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +>longestObjectsWithPartialPadding : { a: number | undefined; b: string | undefined; }[] +>a : number | undefined +>b : string | undefined +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}).toArray() : { a: 1 | undefined; b: "a" | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}).toArray : () => { a: 1 | undefined; b: "a" | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}) : IteratorObject<{ a: 1 | undefined; b: "a" | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : | Iterator; }>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined) => IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown> +>zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; } >{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >a : readonly [1] @@ -185,7 +387,29 @@ Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { >b : "a" >"a" : "a" -}); +}).toArray(); +>toArray : () => { a: 1 | undefined; b: "a" | undefined; }[] + +const maybeLongestObjects: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray(); +>maybeLongestObjects : { a: number | undefined; b: string | undefined; }[] +>a : number | undefined +>b : string | undefined +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray() : { a: 1 | undefined; b: "a" | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray : () => { a: 1 | undefined; b: "a" | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions) : IteratorObject<{ a: 1 | undefined; b: "a" | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; } +>{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } +>{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } +>a : readonly [1] +>[1] : readonly [1] +>1 : 1 +>b : readonly ["a"] +>["a"] : readonly ["a"] +>"a" : "a" +>maybeLongestOptions : { mode: "shortest"; } | { mode: "longest"; } +>toArray : () => { a: 1 | undefined; b: "a" | undefined; }[] interface Inputs { a: Iterable; @@ -205,18 +429,17 @@ const rows: { a: number; b: string; }[] = Iterator.zipKeyed(inputs).toArray(); >Iterator.zipKeyed(inputs).toArray() : { a: number; b: string; }[] >Iterator.zipKeyed(inputs).toArray : () => { a: number; b: string; }[] >Iterator.zipKeyed(inputs) : IteratorObject<{ a: number; b: string; }, undefined, unknown> ->Iterator.zipKeyed : | Iterator; }>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined) => IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : | Iterator; }>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined) => IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown> +>zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; } >inputs : Inputs >toArray : () => { a: number; b: string; }[] -// @ts-expect-error invalid mode Iterator.zip([[1]], { mode: "invalid" }); >Iterator.zip([[1]], { mode: "invalid" }) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } >[[1]] : [number[]] >[1] : number[] >1 : 1 @@ -224,12 +447,11 @@ Iterator.zip([[1]], { mode: "invalid" }); >mode : "invalid" >"invalid" : "invalid" -// @ts-expect-error padding values must match the input element types Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }); >Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } >[[1], ["a"]] as const : readonly [readonly [1], readonly ["a"]] >[[1], ["a"]] : readonly [readonly [1], readonly ["a"]] >[1] : readonly [1] @@ -243,12 +465,11 @@ Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }); >[true] : boolean[] >true : true -// @ts-expect-error padding is only used in longest mode Iterator.zip([[1]], { mode: "shortest", padding: [1] }); >Iterator.zip([[1]], { mode: "shortest", padding: [1] }) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } >[[1]] : [number[]] >[1] : number[] >1 : 1 @@ -259,20 +480,18 @@ Iterator.zip([[1]], { mode: "shortest", padding: [1] }); >[1] : number[] >1 : 1 -// @ts-expect-error the input must be iterable Iterator.zip(0); >Iterator.zip(0) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator)[] | []>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: (IteratorZipLongestOptions ? U : T extends Iterator ? U_1 : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined): IteratorObject<(T extends Iterable ? U : T extends Iterator ? U_1 : never)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } >0 : 0 -// @ts-expect-error each keyed value must be iterable Iterator.zipKeyed({ a: 0 }); ->Iterator.zipKeyed({ a: 0 }) : IteratorObject<{ a: unknown; }, undefined, unknown> ->Iterator.zipKeyed : | Iterator; }>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined) => IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown> +>Iterator.zipKeyed({ a: 0 }) : IteratorObject<{ a: never; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : | Iterator; }>(iterables: T, options?: (IteratorZipLongestOptions ? U : T_1 extends Iterator ? U_1 : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions) | undefined) => IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable ? U : T_1 extends Iterator ? U_1 : never : never : never; }, undefined, unknown> +>zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; } >{ a: 0 } : { a: number; } >a : number >0 : 0 diff --git a/tsc/testdata/tests/cases/compiler/iteratorChunks.ts b/tsc/testdata/tests/cases/compiler/iteratorChunks.ts index 0a0ae2213de98..b728167b45387 100644 --- a/tsc/testdata/tests/cases/compiler/iteratorChunks.ts +++ b/tsc/testdata/tests/cases/compiler/iteratorChunks.ts @@ -4,5 +4,4 @@ const chunks: number[][] = Iterator.from([1, 2, 3]).chunks(2).toArray(); -// @ts-expect-error chunk size must be a number Iterator.from([1, 2, 3]).chunks("2"); diff --git a/tsc/testdata/tests/cases/compiler/iteratorIncludes.ts b/tsc/testdata/tests/cases/compiler/iteratorIncludes.ts index f1cc2b41991b0..4df0f336f433e 100644 --- a/tsc/testdata/tests/cases/compiler/iteratorIncludes.ts +++ b/tsc/testdata/tests/cases/compiler/iteratorIncludes.ts @@ -5,8 +5,6 @@ const includes: boolean = Iterator.from([1, 2, 3]).includes(2); const includesAfterSkipping: boolean = Iterator.from([1, 2, 3]).includes(2, 1); -// @ts-expect-error the searched value must match the iterator value Iterator.from([1, 2, 3]).includes("1"); -// @ts-expect-error skipped elements must be a number Iterator.from([1, 2, 3]).includes(2, "1"); diff --git a/tsc/testdata/tests/cases/compiler/iteratorJoin.ts b/tsc/testdata/tests/cases/compiler/iteratorJoin.ts index 5e5ebee1fc07c..9ca68e0037163 100644 --- a/tsc/testdata/tests/cases/compiler/iteratorJoin.ts +++ b/tsc/testdata/tests/cases/compiler/iteratorJoin.ts @@ -5,5 +5,4 @@ const joined: string = Iterator.from([1, 2, 3]).join("-"); const joinedWithDefaultSeparator: string = Iterator.from([1, 2, 3]).join(); -// @ts-expect-error separator must be a string Iterator.from([1, 2, 3]).join(0); diff --git a/tsc/testdata/tests/cases/compiler/iteratorZip.ts b/tsc/testdata/tests/cases/compiler/iteratorZip.ts index 2b7fda5c88c30..297e8748110b4 100644 --- a/tsc/testdata/tests/cases/compiler/iteratorZip.ts +++ b/tsc/testdata/tests/cases/compiler/iteratorZip.ts @@ -11,14 +11,25 @@ const tuples: [number, string][] = Iterator.zip([ tuples[0][0] = 2; -Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }); -Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }); -Iterator.zip([[1], ["a"]] as const, { mode: "strict" }); +const shortestTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray(); +const strictTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray(); +const longestTuplesWithPadding: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray(); +const longestTuplesWithoutPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray(); +const longestTuplesWithPartialPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray(); + +declare const maybeLongestOptions: { mode: "shortest"; } | { mode: "longest"; }; +const maybeLongestTuples: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray(); const empty: never[] = Iterator.zip([]).toArray(); +const emptyLongest: never[] = Iterator.zip([], { mode: "longest" }).toArray(); declare const iterables: Iterable>; const arrays: number[][] = Iterator.zip(iterables).toArray(); +const longestArrays: (number | undefined)[][] = Iterator.zip(iterables, { mode: "longest" }).toArray(); +const maybeLongestArrays: (number | undefined)[][] = Iterator.zip(iterables, maybeLongestOptions).toArray(); + +declare const iterableArray: Iterable[]; +const longestArrayWithPadding: (number | undefined)[][] = Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray(); const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ a: [1, 2], @@ -28,10 +39,21 @@ const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ objects[0].a = 2; -Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +const longestObjectsWithPadding: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { + mode: "longest", + padding: { a: 1, b: "a" }, +}).toArray(); + +const longestObjectsWithoutPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { + mode: "longest", +}).toArray(); + +const longestObjectsWithPartialPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" }, -}); +}).toArray(); + +const maybeLongestObjects: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray(); interface Inputs { a: Iterable; @@ -41,17 +63,12 @@ interface Inputs { declare const inputs: Inputs; const rows: { a: number; b: string; }[] = Iterator.zipKeyed(inputs).toArray(); -// @ts-expect-error invalid mode Iterator.zip([[1]], { mode: "invalid" }); -// @ts-expect-error padding values must match the input element types Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }); -// @ts-expect-error padding is only used in longest mode Iterator.zip([[1]], { mode: "shortest", padding: [1] }); -// @ts-expect-error the input must be iterable Iterator.zip(0); -// @ts-expect-error each keyed value must be iterable Iterator.zipKeyed({ a: 0 }); From 0c47c4d63d118e04046349f77daa97a2abf9f70c Mon Sep 17 00:00:00 2001 From: Oleksandr Tarasiuk Date: Fri, 4 Sep 2026 22:53:15 +0300 Subject: [PATCH 3/8] fix zipKeyed empty object result type --- .../bundled/libs/lib.esnext.iterator.d.ts | 6 +- .../reference/compiler/iteratorZip.errors.txt | 6 ++ .../reference/compiler/iteratorZip.js | 9 +++ .../reference/compiler/iteratorZip.symbols | 36 +++++++++ .../reference/compiler/iteratorZip.types | 73 +++++++++++++++---- .../tests/cases/compiler/iteratorZip.ts | 6 ++ 6 files changed, 120 insertions(+), 16 deletions(-) diff --git a/tsc/internal/bundled/libs/lib.esnext.iterator.d.ts b/tsc/internal/bundled/libs/lib.esnext.iterator.d.ts index 8cb2052698a9c..86f4710aec889 100644 --- a/tsc/internal/bundled/libs/lib.esnext.iterator.d.ts +++ b/tsc/internal/bundled/libs/lib.esnext.iterator.d.ts @@ -60,6 +60,8 @@ type IteratorZipResult = { -readonly [K in keyof T]: IteratorYield | TExtra; }; +type IteratorZipKeyedResult = T extends unknown ? keyof T extends never ? never : IteratorZipResult : never; + declare global { interface IteratorObject { /** @@ -113,7 +115,7 @@ declare global { * @param iterables An object whose enumerable own properties contain iterators or iterables to zip. * @param options Controls how differing input lengths are handled. */ - zipKeyed(iterables: T & Record>, options?: IteratorZipShortestOptions | (IteratorZipLongestOptions>> & { padding: NoInfer>; }) | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; - zipKeyed(iterables: T & Record>, options: IteratorZipOptions>>>): IteratorObject, undefined, unknown>; + zipKeyed(iterables: T & Record>, options?: IteratorZipShortestOptions | (IteratorZipLongestOptions>> & { padding: NoInfer>; }) | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; + zipKeyed(iterables: T & Record>, options: IteratorZipOptions>>>): IteratorObject, undefined, unknown>; } } diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip.errors.txt b/tsc/testdata/baselines/reference/compiler/iteratorZip.errors.txt index a0d14c8d721a6..b13d7198a7cae 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorZip.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/iteratorZip.errors.txt @@ -117,4 +117,10 @@ iteratorZip.ts(70,21): error TS2322: Type 'number' is not assignable to type 'nu ~ !!! error TS2322: Type 'number' is not assignable to type 'number & IteratorInput'. !!! related TS6500 iteratorZip.ts:70:21: The expected type comes from property 'a' which is declared here on type '{ a: number; } & Record<"a", IteratorInput>' + + const emptyKeyed: never[] = Iterator.zipKeyed({}).toArray(); + const emptyKeyedLongest: never[] = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); + + declare const unionInputs: { a: Iterable; } | { b: Iterator; }; + const unionRows: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(unionInputs).toArray(); \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip.js b/tsc/testdata/baselines/reference/compiler/iteratorZip.js index ea5e813d79631..1778dfc79897e 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorZip.js +++ b/tsc/testdata/baselines/reference/compiler/iteratorZip.js @@ -71,6 +71,12 @@ Iterator.zip([[1]], { mode: "shortest", padding: [1] }); Iterator.zip(0); Iterator.zipKeyed({ a: 0 }); + +const emptyKeyed: never[] = Iterator.zipKeyed({}).toArray(); +const emptyKeyedLongest: never[] = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); + +declare const unionInputs: { a: Iterable; } | { b: Iterator; }; +const unionRows: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(unionInputs).toArray(); //// [iteratorZip.js] @@ -116,3 +122,6 @@ Iterator.zip([[1], ["a"]], { mode: "longest", padding: [true] }); Iterator.zip([[1]], { mode: "shortest", padding: [1] }); Iterator.zip(0); Iterator.zipKeyed({ a: 0 }); +const emptyKeyed = Iterator.zipKeyed({}).toArray(); +const emptyKeyedLongest = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); +const unionRows = Iterator.zipKeyed(unionInputs).toArray(); diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip.symbols b/tsc/testdata/baselines/reference/compiler/iteratorZip.symbols index c427139883826..10fc6e6f57e02 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorZip.symbols +++ b/tsc/testdata/baselines/reference/compiler/iteratorZip.symbols @@ -323,3 +323,39 @@ Iterator.zipKeyed({ a: 0 }); >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >a : Symbol(a, Decl(iteratorZip.ts, 69, 19)) +const emptyKeyed: never[] = Iterator.zipKeyed({}).toArray(); +>emptyKeyed : Symbol(emptyKeyed, Decl(iteratorZip.ts, 71, 5)) +>Iterator.zipKeyed({}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const emptyKeyedLongest: never[] = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); +>emptyKeyedLongest : Symbol(emptyKeyedLongest, Decl(iteratorZip.ts, 72, 5)) +>Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 72, 58)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 72, 75)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const unionInputs: { a: Iterable; } | { b: Iterator; }; +>unionInputs : Symbol(unionInputs, Decl(iteratorZip.ts, 74, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 74, 28)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>b : Symbol(b, Decl(iteratorZip.ts, 74, 55)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) + +const unionRows: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(unionInputs).toArray(); +>unionRows : Symbol(unionRows, Decl(iteratorZip.ts, 75, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 75, 19)) +>b : Symbol(b, Decl(iteratorZip.ts, 75, 36)) +>Iterator.zipKeyed(unionInputs).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>unionInputs : Symbol(unionInputs, Decl(iteratorZip.ts, 74, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip.types b/tsc/testdata/baselines/reference/compiler/iteratorZip.types index 3b6109820c9b3..e6fb973b24696 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorZip.types +++ b/tsc/testdata/baselines/reference/compiler/iteratorZip.types @@ -256,9 +256,9 @@ const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ >Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const).toArray() : { a: 1 | 2; b: string; [key]: boolean; }[] >Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const).toArray : () => { a: 1 | 2; b: string; [key]: boolean; }[] >Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const) : IteratorObject<{ a: 1 | 2; b: string; [key]: boolean; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; } +>zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } >{ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const : { readonly a: readonly [1, 2]; readonly b: Set; readonly [key]: readonly [true, false]; } >{ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} : { readonly a: readonly [1, 2]; readonly b: Set; readonly [key]: readonly [true, false]; } @@ -302,9 +302,9 @@ const longestObjectsWithPadding: { a: number; b: string; }[] = Iterator.zipKeyed >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}).toArray() : { a: 1; b: "a"; }[] >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}).toArray : () => { a: 1; b: "a"; }[] >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}) : IteratorObject<{ a: 1; b: "a"; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; } +>zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } >{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >a : readonly [1] @@ -337,9 +337,9 @@ const longestObjectsWithoutPadding: { a: number | undefined; b: string | undefin >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}).toArray() : { a: 1 | undefined; b: "a" | undefined; }[] >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}).toArray : () => { a: 1 | undefined; b: "a" | undefined; }[] >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}) : IteratorObject<{ a: 1 | undefined; b: "a" | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; } +>zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } >{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >a : readonly [1] @@ -364,9 +364,9 @@ const longestObjectsWithPartialPadding: { a: number | undefined; b: string | und >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}).toArray() : { a: 1 | undefined; b: "a" | undefined; }[] >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}).toArray : () => { a: 1 | undefined; b: "a" | undefined; }[] >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}) : IteratorObject<{ a: 1 | undefined; b: "a" | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; } +>zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } >{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >a : readonly [1] @@ -397,9 +397,9 @@ const maybeLongestObjects: { a: number | undefined; b: string | undefined; }[] = >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray() : { a: 1 | undefined; b: "a" | undefined; }[] >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray : () => { a: 1 | undefined; b: "a" | undefined; }[] >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions) : IteratorObject<{ a: 1 | undefined; b: "a" | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; } +>zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } >{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >a : readonly [1] @@ -429,9 +429,9 @@ const rows: { a: number; b: string; }[] = Iterator.zipKeyed(inputs).toArray(); >Iterator.zipKeyed(inputs).toArray() : { a: number; b: string; }[] >Iterator.zipKeyed(inputs).toArray : () => { a: number; b: string; }[] >Iterator.zipKeyed(inputs) : IteratorObject<{ a: number; b: string; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; } +>zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } >inputs : Inputs >toArray : () => { a: number; b: string; }[] @@ -489,10 +489,55 @@ Iterator.zip(0); Iterator.zipKeyed({ a: 0 }); >Iterator.zipKeyed({ a: 0 }) : IteratorObject<{ a: never; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; } +>zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } >{ a: 0 } : { a: number; } >a : number >0 : 0 +const emptyKeyed: never[] = Iterator.zipKeyed({}).toArray(); +>emptyKeyed : never[] +>Iterator.zipKeyed({}).toArray() : never[] +>Iterator.zipKeyed({}).toArray : () => never[] +>Iterator.zipKeyed({}) : IteratorObject +>Iterator.zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } +>{} : {} +>toArray : () => never[] + +const emptyKeyedLongest: never[] = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); +>emptyKeyedLongest : never[] +>Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray() : never[] +>Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray : () => never[] +>Iterator.zipKeyed({}, { mode: "longest", padding: {} }) : IteratorObject +>Iterator.zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } +>{} : {} +>{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } +>mode : "longest" +>"longest" : "longest" +>padding : {} +>{} : {} +>toArray : () => never[] + +declare const unionInputs: { a: Iterable; } | { b: Iterator; }; +>unionInputs : { a: Iterable; } | { b: Iterator; } +>a : Iterable +>b : Iterator + +const unionRows: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(unionInputs).toArray(); +>unionRows : ({ a: number; } | { b: string; })[] +>a : number +>b : string +>Iterator.zipKeyed(unionInputs).toArray() : ({ a: number; } | { b: string; })[] +>Iterator.zipKeyed(unionInputs).toArray : () => ({ a: number; } | { b: string; })[] +>Iterator.zipKeyed(unionInputs) : IteratorObject<{ a: number; } | { b: string; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } +>unionInputs : { a: Iterable; } | { b: Iterator; } +>toArray : () => ({ a: number; } | { b: string; })[] + diff --git a/tsc/testdata/tests/cases/compiler/iteratorZip.ts b/tsc/testdata/tests/cases/compiler/iteratorZip.ts index 297e8748110b4..46c7549670eb9 100644 --- a/tsc/testdata/tests/cases/compiler/iteratorZip.ts +++ b/tsc/testdata/tests/cases/compiler/iteratorZip.ts @@ -72,3 +72,9 @@ Iterator.zip([[1]], { mode: "shortest", padding: [1] }); Iterator.zip(0); Iterator.zipKeyed({ a: 0 }); + +const emptyKeyed: never[] = Iterator.zipKeyed({}).toArray(); +const emptyKeyedLongest: never[] = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); + +declare const unionInputs: { a: Iterable; } | { b: Iterator; }; +const unionRows: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(unionInputs).toArray(); From 1a31a5e95e8b3c5732caaa46a413e13ea4a6dae7 Mon Sep 17 00:00:00 2001 From: Oleksandr Tarasiuk Date: Fri, 25 Sep 2026 12:00:00 +0300 Subject: [PATCH 4/8] improve iterator zip typings --- .../bundled/libs/lib.esnext.iterator.d.ts | 45 +- .../reference/compiler/iteratorZip.errors.txt | 38 +- .../reference/compiler/iteratorZip.symbols | 40 +- .../reference/compiler/iteratorZip.types | 150 ++--- ...actoptionalpropertytypes=false).errors.txt | 266 +++++++++ ...nputs(exactoptionalpropertytypes=false).js | 208 +++++++ ...(exactoptionalpropertytypes=false).symbols | 388 +++++++++++++ ...ts(exactoptionalpropertytypes=false).types | 511 ++++++++++++++++ ...xactoptionalpropertytypes=true).errors.txt | 262 +++++++++ ...Inputs(exactoptionalpropertytypes=true).js | 208 +++++++ ...s(exactoptionalpropertytypes=true).symbols | 388 +++++++++++++ ...uts(exactoptionalpropertytypes=true).types | 511 ++++++++++++++++ ...actoptionalpropertytypes=false).errors.txt | 215 +++++++ ...dding(exactoptionalpropertytypes=false).js | 248 ++++++++ ...(exactoptionalpropertytypes=false).symbols | 393 +++++++++++++ ...ng(exactoptionalpropertytypes=false).types | 549 ++++++++++++++++++ ...xactoptionalpropertytypes=true).errors.txt | 215 +++++++ ...adding(exactoptionalpropertytypes=true).js | 248 ++++++++ ...g(exactoptionalpropertytypes=true).symbols | 393 +++++++++++++ ...ing(exactoptionalpropertytypes=true).types | 549 ++++++++++++++++++ .../tests/cases/compiler/iteratorZipInputs.ts | 70 +++ .../cases/compiler/iteratorZipPadding.ts | 72 +++ 22 files changed, 5841 insertions(+), 126 deletions(-) create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=false).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=false).js create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=false).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=false).types create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=true).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=true).js create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=true).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=true).types create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=false).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=false).js create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=false).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=false).types create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=true).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=true).js create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=true).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=true).types create mode 100644 tsc/testdata/tests/cases/compiler/iteratorZipInputs.ts create mode 100644 tsc/testdata/tests/cases/compiler/iteratorZipPadding.ts diff --git a/tsc/internal/bundled/libs/lib.esnext.iterator.d.ts b/tsc/internal/bundled/libs/lib.esnext.iterator.d.ts index 86f4710aec889..47c59519dd81f 100644 --- a/tsc/internal/bundled/libs/lib.esnext.iterator.d.ts +++ b/tsc/internal/bundled/libs/lib.esnext.iterator.d.ts @@ -50,17 +50,33 @@ type IteratorZipOptions = | IteratorZipLongestOptions | IteratorZipStrictOptions; -type IteratorInput = Iterable | Iterator; - -type IteratorInputTuple = readonly [] | readonly [IteratorInput, ...IteratorInput[]]; +type IteratorInput = (Iterable | Iterator) & object; type IteratorYield = T extends IteratorInput ? U : never; -type IteratorZipResult = { - -readonly [K in keyof T]: IteratorYield | TExtra; +type IteratorZipPadding = { + readonly [K in keyof T]?: IteratorYield | undefined; +}; + +type IteratorZipPaddingKeys = keyof { + [K in keyof T as {} extends Pick ? never : K]: unknown; +}; + +type IteratorZipResult = { + -readonly [K in keyof T]: IteratorYield | (K extends keyof TPadding ? TPadding[K] : never) | (K extends IteratorZipPaddingKeys ? never : TExtra); +}; + +type IteratorZipKeyedInput = { + [K in T extends unknown ? keyof T : never]?: IteratorInput | undefined; }; -type IteratorZipKeyedResult = T extends unknown ? keyof T extends never ? never : IteratorZipResult : never; +type IteratorZipKeyedResult = T extends Partial> ? never + : IteratorZipResult< + { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & + { [K in keyof T as undefined extends T[K] ? T[K] extends undefined ? never : K : never]?: T[K]; }, + TExtra, + TPadding + >; declare global { interface IteratorObject { @@ -91,31 +107,32 @@ declare global { * @param iterables An iterable of iterators or iterables to zip. * @param options Controls how differing input lengths are handled. */ - zip(iterables: readonly [], options?: IteratorZipOptions>): IteratorObject; + zip(iterables: readonly [], options?: IteratorZipOptions & object>): IteratorObject; /** * Creates an iterator whose values are arrays containing values yielded at the same position by each input iterator or iterable. * @param iterables An iterable of iterators or iterables to zip. * @param options Controls how differing input lengths are handled. */ - zip(iterables: T, options: IteratorZipLongestOptions>> & { padding: NoInfer>; }): IteratorObject, undefined, unknown>; zip[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; - zip[] | []>(iterables: T, options: IteratorZipOptions>>>): IteratorObject, undefined, unknown>; + zip[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer>; }): IteratorObject, undefined, unknown>; + zip[] | []>(iterables: T, options: IteratorZipOptions>>): IteratorObject, undefined, unknown>; /** * Creates an iterator whose values are arrays containing values yielded at the same position by each input iterator or iterable. * @param iterables An iterable of iterators or iterables to zip. * @param options Controls how differing input lengths are handled. */ - zip>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject[], undefined, unknown>; - zip>(iterables: Iterable, options: IteratorZipOptions>>>): IteratorObject<(IteratorYield | undefined)[], undefined, unknown>; + zip>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject[], undefined, unknown>; + zip>(iterables: Iterable & object, options: IteratorZipOptions | undefined> & object>>): IteratorObject<(IteratorYield | undefined)[], undefined, unknown>; /** * Creates an iterator whose values are objects containing values yielded at the same position by each iterator or iterable in the input object. - * @param iterables An object whose enumerable own properties contain iterators or iterables to zip. + * @param iterables An object whose enumerable own properties contain iterators or iterables to zip. Undefined values are ignored. * @param options Controls how differing input lengths are handled. */ - zipKeyed(iterables: T & Record>, options?: IteratorZipShortestOptions | (IteratorZipLongestOptions>> & { padding: NoInfer>; }) | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; - zipKeyed(iterables: T & Record>, options: IteratorZipOptions>>>): IteratorObject, undefined, unknown>; + zipKeyed(iterables: T & IteratorZipKeyedInput, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; + zipKeyed(iterables: T & IteratorZipKeyedInput, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer>; }): IteratorObject, undefined, unknown>; + zipKeyed(iterables: T & IteratorZipKeyedInput, options: IteratorZipOptions & object>>): IteratorObject, undefined, unknown>; } } diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip.errors.txt b/tsc/testdata/baselines/reference/compiler/iteratorZip.errors.txt index b13d7198a7cae..9779d2d2cda6a 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorZip.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/iteratorZip.errors.txt @@ -3,19 +3,21 @@ iteratorZip.ts(62,23): error TS2769: No overload matches this call. Type '"invalid"' is not assignable to type '"longest" | "shortest" | "strict" | undefined'. iteratorZip.ts(64,56): error TS2769: No overload matches this call. The last overload gave the following error. - Type 'true[]' is not assignable to type 'Iterable<"a" | 1>'. - The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. - Type 'IteratorResult' is not assignable to type 'IteratorResult<"a" | 1, any>'. - Type 'IteratorYieldResult' is not assignable to type 'IteratorResult<"a" | 1, any>'. - Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult<"a" | 1>'. - Type 'true' is not assignable to type '"a" | 1'. + Type 'true[]' is not assignable to type 'Iterable<"a" | 1 | undefined> & object'. + Type 'true[]' is not assignable to type 'Iterable<"a" | 1 | undefined>'. + The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. + Type 'IteratorResult' is not assignable to type 'IteratorResult<"a" | 1 | undefined, any>'. + Type 'IteratorYieldResult' is not assignable to type 'IteratorResult<"a" | 1 | undefined, any>'. + Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult<"a" | 1 | undefined>'. + Type 'true' is not assignable to type '"a" | 1 | undefined'. iteratorZip.ts(66,41): error TS2769: No overload matches this call. The last overload gave the following error. Object literal may only specify known properties, and 'padding' does not exist in type 'IteratorZipShortestOptions'. iteratorZip.ts(68,14): error TS2769: No overload matches this call. The last overload gave the following error. - Argument of type 'number' is not assignable to parameter of type 'Iterable>'. -iteratorZip.ts(70,21): error TS2322: Type 'number' is not assignable to type 'number & IteratorInput'. + Argument of type 'number' is not assignable to parameter of type 'Iterable> & object'. + Type 'number' is not assignable to type 'Iterable>'. +iteratorZip.ts(70,21): error TS2322: Type 'number' is not assignable to type 'never'. ==== iteratorZip.ts (5 errors) ==== @@ -91,12 +93,13 @@ iteratorZip.ts(70,21): error TS2322: Type 'number' is not assignable to type 'nu ~~~~~~~ !!! error TS2769: No overload matches this call. !!! error TS2769: The last overload gave the following error. -!!! error TS2769: Type 'true[]' is not assignable to type 'Iterable<"a" | 1>'. -!!! error TS2769: The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. -!!! error TS2769: Type 'IteratorResult' is not assignable to type 'IteratorResult<"a" | 1, any>'. -!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorResult<"a" | 1, any>'. -!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult<"a" | 1>'. -!!! error TS2769: Type 'true' is not assignable to type '"a" | 1'. +!!! error TS2769: Type 'true[]' is not assignable to type 'Iterable<"a" | 1 | undefined> & object'. +!!! error TS2769: Type 'true[]' is not assignable to type 'Iterable<"a" | 1 | undefined>'. +!!! error TS2769: The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. +!!! error TS2769: Type 'IteratorResult' is not assignable to type 'IteratorResult<"a" | 1 | undefined, any>'. +!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorResult<"a" | 1 | undefined, any>'. +!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult<"a" | 1 | undefined>'. +!!! error TS2769: Type 'true' is not assignable to type '"a" | 1 | undefined'. !!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. Iterator.zip([[1]], { mode: "shortest", padding: [1] }); @@ -110,13 +113,14 @@ iteratorZip.ts(70,21): error TS2322: Type 'number' is not assignable to type 'nu ~ !!! error TS2769: No overload matches this call. !!! error TS2769: The last overload gave the following error. -!!! error TS2769: Argument of type 'number' is not assignable to parameter of type 'Iterable>'. +!!! error TS2769: Argument of type 'number' is not assignable to parameter of type 'Iterable> & object'. +!!! error TS2769: Type 'number' is not assignable to type 'Iterable>'. !!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. Iterator.zipKeyed({ a: 0 }); ~ -!!! error TS2322: Type 'number' is not assignable to type 'number & IteratorInput'. -!!! related TS6500 iteratorZip.ts:70:21: The expected type comes from property 'a' which is declared here on type '{ a: number; } & Record<"a", IteratorInput>' +!!! error TS2322: Type 'number' is not assignable to type 'never'. +!!! related TS6500 iteratorZip.ts:70:21: The expected type comes from property 'a' which is declared here on type '{ a: number; } & IteratorZipKeyedInput<{ a: number; }>' const emptyKeyed: never[] = Iterator.zipKeyed({}).toArray(); const emptyKeyedLongest: never[] = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip.symbols b/tsc/testdata/baselines/reference/compiler/iteratorZip.symbols index 10fc6e6f57e02..756edf1dab36c 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorZip.symbols +++ b/tsc/testdata/baselines/reference/compiler/iteratorZip.symbols @@ -163,9 +163,9 @@ const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ >[key] : Symbol([key], Decl(iteratorZip.ts, 29, 38)) >key : Symbol(key, Decl(iteratorZip.ts, 0, 13)) >Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) a: [1, 2], >a : Symbol(a, Decl(iteratorZip.ts, 29, 80)) @@ -192,9 +192,9 @@ const longestObjectsWithPadding: { a: number; b: string; }[] = Iterator.zipKeyed >a : Symbol(a, Decl(iteratorZip.ts, 37, 34)) >b : Symbol(b, Decl(iteratorZip.ts, 37, 45)) >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >a : Symbol(a, Decl(iteratorZip.ts, 37, 82)) >b : Symbol(b, Decl(iteratorZip.ts, 37, 90)) >const : Symbol(const) @@ -215,9 +215,9 @@ const longestObjectsWithoutPadding: { a: number | undefined; b: string | undefin >a : Symbol(a, Decl(iteratorZip.ts, 42, 37)) >b : Symbol(b, Decl(iteratorZip.ts, 42, 60)) >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >a : Symbol(a, Decl(iteratorZip.ts, 42, 109)) >b : Symbol(b, Decl(iteratorZip.ts, 42, 117)) >const : Symbol(const) @@ -233,9 +233,9 @@ const longestObjectsWithPartialPadding: { a: number | undefined; b: string | und >a : Symbol(a, Decl(iteratorZip.ts, 46, 41)) >b : Symbol(b, Decl(iteratorZip.ts, 46, 64)) >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >a : Symbol(a, Decl(iteratorZip.ts, 46, 113)) >b : Symbol(b, Decl(iteratorZip.ts, 46, 121)) >const : Symbol(const) @@ -255,9 +255,9 @@ const maybeLongestObjects: { a: number | undefined; b: string | undefined; }[] = >a : Symbol(a, Decl(iteratorZip.ts, 51, 28)) >b : Symbol(b, Decl(iteratorZip.ts, 51, 51)) >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >a : Symbol(a, Decl(iteratorZip.ts, 51, 100)) >b : Symbol(b, Decl(iteratorZip.ts, 51, 108)) >const : Symbol(const) @@ -285,9 +285,9 @@ const rows: { a: number; b: string; }[] = Iterator.zipKeyed(inputs).toArray(); >a : Symbol(a, Decl(iteratorZip.ts, 59, 13)) >b : Symbol(b, Decl(iteratorZip.ts, 59, 24)) >Iterator.zipKeyed(inputs).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >inputs : Symbol(inputs, Decl(iteratorZip.ts, 58, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) @@ -318,25 +318,25 @@ Iterator.zip(0); >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) Iterator.zipKeyed({ a: 0 }); ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >a : Symbol(a, Decl(iteratorZip.ts, 69, 19)) const emptyKeyed: never[] = Iterator.zipKeyed({}).toArray(); >emptyKeyed : Symbol(emptyKeyed, Decl(iteratorZip.ts, 71, 5)) >Iterator.zipKeyed({}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const emptyKeyedLongest: never[] = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); >emptyKeyedLongest : Symbol(emptyKeyedLongest, Decl(iteratorZip.ts, 72, 5)) >Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >mode : Symbol(mode, Decl(iteratorZip.ts, 72, 58)) >padding : Symbol(padding, Decl(iteratorZip.ts, 72, 75)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) @@ -353,9 +353,9 @@ const unionRows: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(unionIn >a : Symbol(a, Decl(iteratorZip.ts, 75, 19)) >b : Symbol(b, Decl(iteratorZip.ts, 75, 36)) >Iterator.zipKeyed(unionInputs).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >unionInputs : Symbol(unionInputs, Decl(iteratorZip.ts, 74, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip.types b/tsc/testdata/baselines/reference/compiler/iteratorZip.types index e6fb973b24696..e2cb32e858091 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorZip.types +++ b/tsc/testdata/baselines/reference/compiler/iteratorZip.types @@ -9,9 +9,9 @@ const tuples: [number, string][] = Iterator.zip([ >Iterator.zip([ [1, 2], new Set(["a", "b"]),] as const).toArray() : [1 | 2, string][] >Iterator.zip([ [1, 2], new Set(["a", "b"]),] as const).toArray : () => [1 | 2, string][] >Iterator.zip([ [1, 2], new Set(["a", "b"]),] as const) : IteratorObject<[1 | 2, string], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[ [1, 2], new Set(["a", "b"]),] as const : [readonly [1, 2], Set] >[ [1, 2], new Set(["a", "b"]),] : [readonly [1, 2], Set] @@ -44,9 +44,9 @@ const shortestTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { >Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray() : [1, "a"][] >Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray : () => [1, "a"][] >Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }) : IteratorObject<[1, "a"], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[[1], ["a"]] as const : [readonly [1], readonly ["a"]] >[[1], ["a"]] : [readonly [1], readonly ["a"]] >[1] : readonly [1] @@ -63,9 +63,9 @@ const strictTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { m >Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray() : [1, "a"][] >Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray : () => [1, "a"][] >Iterator.zip([[1], ["a"]] as const, { mode: "strict" }) : IteratorObject<[1, "a"], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[[1], ["a"]] as const : [readonly [1], readonly ["a"]] >[[1], ["a"]] : [readonly [1], readonly ["a"]] >[1] : readonly [1] @@ -79,14 +79,14 @@ const strictTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { m const longestTuplesWithPadding: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray(); >longestTuplesWithPadding : [number, string][] ->Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray() : [1, "a"][] ->Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray : () => [1, "a"][] ->Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }) : IteratorObject<[1, "a"], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray() : [number, string][] +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray : () => [number, string][] +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }) : IteratorObject<[number, string], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } ->[[1], ["a"]] as const : readonly [readonly [1], readonly ["a"]] ->[[1], ["a"]] : readonly [readonly [1], readonly ["a"]] +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] as const : [readonly [1], readonly ["a"]] +>[[1], ["a"]] : [readonly [1], readonly ["a"]] >[1] : readonly [1] >1 : 1 >["a"] : readonly ["a"] @@ -98,16 +98,16 @@ const longestTuplesWithPadding: [number, string][] = Iterator.zip([[1], ["a"]] a >[1, "a"] : [1, "a"] >1 : 1 >"a" : "a" ->toArray : () => [1, "a"][] +>toArray : () => [number, string][] const longestTuplesWithoutPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray(); >longestTuplesWithoutPadding : [number | undefined, string | undefined][] >Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray() : [1 | undefined, "a" | undefined][] >Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray : () => [1 | undefined, "a" | undefined][] >Iterator.zip([[1], ["a"]] as const, { mode: "longest" }) : IteratorObject<[1 | undefined, "a" | undefined], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[[1], ["a"]] as const : [readonly [1], readonly ["a"]] >[[1], ["a"]] : [readonly [1], readonly ["a"]] >[1] : readonly [1] @@ -121,12 +121,12 @@ const longestTuplesWithoutPadding: [number | undefined, string | undefined][] = const longestTuplesWithPartialPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray(); >longestTuplesWithPartialPadding : [number | undefined, string | undefined][] ->Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray() : [1 | undefined, "a" | undefined][] ->Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray : () => [1 | undefined, "a" | undefined][] ->Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }) : IteratorObject<[1 | undefined, "a" | undefined], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray() : [number, "a" | undefined][] +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray : () => [number, "a" | undefined][] +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }) : IteratorObject<[number, "a" | undefined], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[[1], ["a"]] as const : [readonly [1], readonly ["a"]] >[[1], ["a"]] : [readonly [1], readonly ["a"]] >[1] : readonly [1] @@ -139,7 +139,7 @@ const longestTuplesWithPartialPadding: [number | undefined, string | undefined][ >padding : [1] >[1] : [1] >1 : 1 ->toArray : () => [1 | undefined, "a" | undefined][] +>toArray : () => [number, "a" | undefined][] declare const maybeLongestOptions: { mode: "shortest"; } | { mode: "longest"; }; >maybeLongestOptions : { mode: "shortest"; } | { mode: "longest"; } @@ -151,9 +151,9 @@ const maybeLongestTuples: [number | undefined, string | undefined][] = Iterator. >Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray() : [1 | undefined, "a" | undefined][] >Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray : () => [1 | undefined, "a" | undefined][] >Iterator.zip([[1], ["a"]] as const, maybeLongestOptions) : IteratorObject<[1 | undefined, "a" | undefined], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[[1], ["a"]] as const : [readonly [1], readonly ["a"]] >[[1], ["a"]] : [readonly [1], readonly ["a"]] >[1] : readonly [1] @@ -168,9 +168,9 @@ const empty: never[] = Iterator.zip([]).toArray(); >Iterator.zip([]).toArray() : never[] >Iterator.zip([]).toArray : () => never[] >Iterator.zip([]) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[] : [] >toArray : () => never[] @@ -179,9 +179,9 @@ const emptyLongest: never[] = Iterator.zip([], { mode: "longest" }).toArray(); >Iterator.zip([], { mode: "longest" }).toArray() : never[] >Iterator.zip([], { mode: "longest" }).toArray : () => never[] >Iterator.zip([], { mode: "longest" }) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[] : [] >{ mode: "longest" } : { mode: "longest"; } >mode : "longest" @@ -196,9 +196,9 @@ const arrays: number[][] = Iterator.zip(iterables).toArray(); >Iterator.zip(iterables).toArray() : number[][] >Iterator.zip(iterables).toArray : () => number[][] >Iterator.zip(iterables) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >iterables : Iterable> >toArray : () => number[][] @@ -207,9 +207,9 @@ const longestArrays: (number | undefined)[][] = Iterator.zip(iterables, { mode: >Iterator.zip(iterables, { mode: "longest" }).toArray() : (number | undefined)[][] >Iterator.zip(iterables, { mode: "longest" }).toArray : () => (number | undefined)[][] >Iterator.zip(iterables, { mode: "longest" }) : IteratorObject<(number | undefined)[], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >iterables : Iterable> >{ mode: "longest" } : { mode: "longest"; } >mode : "longest" @@ -221,9 +221,9 @@ const maybeLongestArrays: (number | undefined)[][] = Iterator.zip(iterables, may >Iterator.zip(iterables, maybeLongestOptions).toArray() : (number | undefined)[][] >Iterator.zip(iterables, maybeLongestOptions).toArray : () => (number | undefined)[][] >Iterator.zip(iterables, maybeLongestOptions) : IteratorObject<(number | undefined)[], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >iterables : Iterable> >maybeLongestOptions : { mode: "shortest"; } | { mode: "longest"; } >toArray : () => (number | undefined)[][] @@ -236,15 +236,15 @@ const longestArrayWithPadding: (number | undefined)[][] = Iterator.zip(iterableA >Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray() : (number | undefined)[][] >Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray : () => (number | undefined)[][] >Iterator.zip(iterableArray, { mode: "longest", padding: [] }) : IteratorObject<(number | undefined)[], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >iterableArray : Iterable[] ->{ mode: "longest", padding: [] } : { mode: "longest"; padding: never[]; } +>{ mode: "longest", padding: [] } : { mode: "longest"; padding: []; } >mode : "longest" >"longest" : "longest" ->padding : never[] ->[] : never[] +>padding : [] +>[] : [] >toArray : () => (number | undefined)[][] const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ @@ -256,9 +256,9 @@ const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ >Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const).toArray() : { a: 1 | 2; b: string; [key]: boolean; }[] >Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const).toArray : () => { a: 1 | 2; b: string; [key]: boolean; }[] >Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const) : IteratorObject<{ a: 1 | 2; b: string; [key]: boolean; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } >{ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const : { readonly a: readonly [1, 2]; readonly b: Set; readonly [key]: readonly [true, false]; } >{ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} : { readonly a: readonly [1, 2]; readonly b: Set; readonly [key]: readonly [true, false]; } @@ -299,12 +299,12 @@ const longestObjectsWithPadding: { a: number; b: string; }[] = Iterator.zipKeyed >longestObjectsWithPadding : { a: number; b: string; }[] >a : number >b : string ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}).toArray() : { a: 1; b: "a"; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}).toArray : () => { a: 1; b: "a"; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}) : IteratorObject<{ a: 1; b: "a"; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}).toArray() : { a: number; b: string; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}).toArray : () => { a: number; b: string; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}) : IteratorObject<{ a: number; b: string; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } >{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >a : readonly [1] @@ -328,7 +328,7 @@ const longestObjectsWithPadding: { a: number; b: string; }[] = Iterator.zipKeyed >"a" : "a" }).toArray(); ->toArray : () => { a: 1; b: "a"; }[] +>toArray : () => { a: number; b: string; }[] const longestObjectsWithoutPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { >longestObjectsWithoutPadding : { a: number | undefined; b: string | undefined; }[] @@ -337,9 +337,9 @@ const longestObjectsWithoutPadding: { a: number | undefined; b: string | undefin >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}).toArray() : { a: 1 | undefined; b: "a" | undefined; }[] >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}).toArray : () => { a: 1 | undefined; b: "a" | undefined; }[] >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}) : IteratorObject<{ a: 1 | undefined; b: "a" | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } >{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >a : readonly [1] @@ -361,12 +361,12 @@ const longestObjectsWithPartialPadding: { a: number | undefined; b: string | und >longestObjectsWithPartialPadding : { a: number | undefined; b: string | undefined; }[] >a : number | undefined >b : string | undefined ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}).toArray() : { a: 1 | undefined; b: "a" | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}).toArray : () => { a: 1 | undefined; b: "a" | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}) : IteratorObject<{ a: 1 | undefined; b: "a" | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}).toArray() : { a: 1 | undefined; b: string; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}).toArray : () => { a: 1 | undefined; b: string; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}) : IteratorObject<{ a: 1 | undefined; b: string; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } >{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >a : readonly [1] @@ -388,7 +388,7 @@ const longestObjectsWithPartialPadding: { a: number | undefined; b: string | und >"a" : "a" }).toArray(); ->toArray : () => { a: 1 | undefined; b: "a" | undefined; }[] +>toArray : () => { a: 1 | undefined; b: string; }[] const maybeLongestObjects: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray(); >maybeLongestObjects : { a: number | undefined; b: string | undefined; }[] @@ -397,9 +397,9 @@ const maybeLongestObjects: { a: number | undefined; b: string | undefined; }[] = >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray() : { a: 1 | undefined; b: "a" | undefined; }[] >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray : () => { a: 1 | undefined; b: "a" | undefined; }[] >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions) : IteratorObject<{ a: 1 | undefined; b: "a" | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } >{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >a : readonly [1] @@ -429,17 +429,17 @@ const rows: { a: number; b: string; }[] = Iterator.zipKeyed(inputs).toArray(); >Iterator.zipKeyed(inputs).toArray() : { a: number; b: string; }[] >Iterator.zipKeyed(inputs).toArray : () => { a: number; b: string; }[] >Iterator.zipKeyed(inputs) : IteratorObject<{ a: number; b: string; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } >inputs : Inputs >toArray : () => { a: number; b: string; }[] Iterator.zip([[1]], { mode: "invalid" }); >Iterator.zip([[1]], { mode: "invalid" }) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[[1]] : [number[]] >[1] : number[] >1 : 1 @@ -449,9 +449,9 @@ Iterator.zip([[1]], { mode: "invalid" }); Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }); >Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[[1], ["a"]] as const : readonly [readonly [1], readonly ["a"]] >[[1], ["a"]] : readonly [readonly [1], readonly ["a"]] >[1] : readonly [1] @@ -467,9 +467,9 @@ Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }); Iterator.zip([[1]], { mode: "shortest", padding: [1] }); >Iterator.zip([[1]], { mode: "shortest", padding: [1] }) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[[1]] : [number[]] >[1] : number[] >1 : 1 @@ -482,16 +482,16 @@ Iterator.zip([[1]], { mode: "shortest", padding: [1] }); Iterator.zip(0); >Iterator.zip(0) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator, ...(Iterable | Iterator)[]]>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }, undefined, unknown>; | Iterator)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never) | undefined; }, undefined, unknown>; | Iterator>(iterables: Iterable, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends Iterable | Iterator ? U : never)[], undefined, unknown>; | Iterator>(iterables: Iterable, options: IteratorZipLongestOptions | Iterator ? U : never>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends Iterable | Iterator ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >0 : 0 Iterator.zipKeyed({ a: 0 }); >Iterator.zipKeyed({ a: 0 }) : IteratorObject<{ a: never; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } >{ a: 0 } : { a: number; } >a : number >0 : 0 @@ -501,9 +501,9 @@ const emptyKeyed: never[] = Iterator.zipKeyed({}).toArray(); >Iterator.zipKeyed({}).toArray() : never[] >Iterator.zipKeyed({}).toArray : () => never[] >Iterator.zipKeyed({}) : IteratorObject ->Iterator.zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } >{} : {} >toArray : () => never[] @@ -512,9 +512,9 @@ const emptyKeyedLongest: never[] = Iterator.zipKeyed({}, { mode: "longest", padd >Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray() : never[] >Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray : () => never[] >Iterator.zipKeyed({}, { mode: "longest", padding: {} }) : IteratorObject ->Iterator.zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } >{} : {} >{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } >mode : "longest" @@ -535,9 +535,9 @@ const unionRows: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(unionIn >Iterator.zipKeyed(unionInputs).toArray() : ({ a: number; } | { b: string; })[] >Iterator.zipKeyed(unionInputs).toArray : () => ({ a: number; } | { b: string; })[] >Iterator.zipKeyed(unionInputs) : IteratorObject<{ a: number; } | { b: string; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & Record | Iterator>, options?: IteratorZipShortestOptions | IteratorZipStrictOptions | (IteratorZipLongestOptions | Iterator ? U : never : never : never; }>> & { padding: NoInfer<{ -readonly [K in keyof T]: T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends Iterable | Iterator ? U : never : never : never; }>; }) | undefined): IteratorObject | Iterator ? U : never : never : never; } : never, undefined, unknown>; (iterables: T & Record | Iterator>, options: IteratorZipLongestOptions | Iterator ? U : never : never : never; }>>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject | Iterator ? U : never : never : never) | undefined; } : never, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } >unionInputs : { a: Iterable; } | { b: Iterator; } >toArray : () => ({ a: number; } | { b: string; })[] diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=false).errors.txt b/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=false).errors.txt new file mode 100644 index 0000000000000..82cb9bbd4a0ca --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=false).errors.txt @@ -0,0 +1,266 @@ +iteratorZipInputs.ts(1,14): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type 'string' is not assignable to parameter of type 'Iterable> & object'. + Type 'string' is not assignable to type 'Iterable>'. +iteratorZipInputs.ts(2,14): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type 'string[]' is not assignable to parameter of type 'Iterable> & object'. + Type 'string[]' is not assignable to type 'Iterable>'. + The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. + Type 'IteratorResult' is not assignable to type 'IteratorResult, any>'. + Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>'. + Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>'. + Type 'string' is not assignable to type 'IteratorInput'. +iteratorZipInputs.ts(3,14): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type 'Set' is not assignable to parameter of type 'Iterable> & object'. + Type 'Set' is not assignable to type 'Iterable>'. + The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. + Type 'IteratorResult' is not assignable to type 'IteratorResult, any>'. + Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>'. + Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>'. + Type 'string' is not assignable to type 'IteratorInput'. +iteratorZipInputs.ts(4,19): error TS2345: Argument of type 'string' is not assignable to parameter of type 'object & IteratorZipKeyedInput'. + Type 'string' is not assignable to type 'object'. +iteratorZipInputs.ts(5,21): error TS2322: Type 'string' is not assignable to type 'never'. +iteratorZipInputs.ts(6,37): error TS2769: No overload matches this call. + The last overload gave the following error. + Type 'string' is not assignable to type 'Iterable & object'. + Type 'string' is not assignable to type 'Iterable'. +iteratorZipInputs.ts(7,42): error TS2769: No overload matches this call. + The last overload gave the following error. + Type 'string' is not assignable to type 'Iterable & object'. + Type 'string' is not assignable to type 'object'. +iteratorZipInputs.ts(8,42): error TS2769: No overload matches this call. + The last overload gave the following error. + Type 'string' is not assignable to type 'object'. +iteratorZipInputs.ts(16,6): error TS2339: Property 'b' does not exist on type 'IteratorZipResult<{ a: number[]; } & {}, never, {}>'. +iteratorZipInputs.ts(32,6): error TS2339: Property 'd' does not exist on type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator | undefined; readonly c?: Iterable | undefined; }, never, {}>'. +iteratorZipInputs.ts(33,7): error TS2322: Type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator | undefined; readonly c?: Iterable | undefined; }, never, {}>[]' is not assignable to type '{ a: number; c: boolean; }[]'. + Type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator | undefined; readonly c?: Iterable | undefined; }, never, {}>' is not assignable to type '{ a: number; c: boolean; }'. + Types of property 'c' are incompatible. + Type 'boolean | undefined' is not assignable to type 'boolean'. + Type 'undefined' is not assignable to type 'boolean'. +iteratorZipInputs.ts(39,19): error TS2345: Argument of type '{ a: Iterable; } | { b: number; }' is not assignable to parameter of type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. + Type '{ b: number; }' is not assignable to type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. + Type '{ b: number; }' is not assignable to type '{ b: number; } & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. + Type '{ b: number; }' is not assignable to type 'IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. + Types of property 'b' are incompatible. + Type 'number' is not assignable to type 'IteratorInput | undefined'. +iteratorZipInputs.ts(40,19): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type '{ a: Iterable; } | { b: number; }' is not assignable to parameter of type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. + Type '{ b: number; }' is not assignable to type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. + Type '{ b: number; }' is not assignable to type '{ b: number; } & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. + Type '{ b: number; }' is not assignable to type 'IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. + Types of property 'b' are incompatible. + Type 'number' is not assignable to type 'IteratorInput | undefined'. +iteratorZipInputs.ts(41,19): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type '{ a: Iterable; } | { b: number; }' is not assignable to parameter of type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. + Type '{ b: number; }' is not assignable to type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. + Type '{ b: number; }' is not assignable to type '{ b: number; } & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. + Type '{ b: number; }' is not assignable to type 'IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. + Types of property 'b' are incompatible. + Type 'number' is not assignable to type 'IteratorInput | undefined'. +iteratorZipInputs.ts(43,19): error TS2345: Argument of type '{ a?: Iterable | undefined; } | { b: string; }' is not assignable to parameter of type '({ a?: Iterable | undefined; } | { b: string; }) & IteratorZipKeyedInput<{ a?: Iterable | undefined; } | { b: string; }>'. + Type '{ b: string; }' is not assignable to type '({ a?: Iterable | undefined; } | { b: string; }) & IteratorZipKeyedInput<{ a?: Iterable | undefined; } | { b: string; }>'. + Type '{ b: string; }' is not assignable to type '{ b: string; } & IteratorZipKeyedInput<{ a?: Iterable | undefined; } | { b: string; }>'. + Type '{ b: string; }' is not assignable to type 'IteratorZipKeyedInput<{ a?: Iterable | undefined; } | { b: string; }>'. + Types of property 'b' are incompatible. + Type 'string' is not assignable to type 'IteratorInput | undefined'. +iteratorZipInputs.ts(51,21): error TS2322: Type 'number[]' is not assignable to type 'never'. +iteratorZipInputs.ts(51,29): error TS2322: Type 'null' is not assignable to type 'never'. +iteratorZipInputs.ts(52,21): error TS2322: Type 'number[]' is not assignable to type 'never'. +iteratorZipInputs.ts(52,29): error TS2322: Type 'false' is not assignable to type 'never'. +iteratorZipInputs.ts(53,14): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type 'undefined[]' is not assignable to parameter of type 'Iterable> & object'. + Type 'undefined[]' is not assignable to type 'Iterable>'. + The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. + Type 'IteratorResult' is not assignable to type 'IteratorResult, any>'. + Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>'. + Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>'. + Type 'undefined' is not assignable to type 'IteratorInput'. + + +==== iteratorZipInputs.ts (20 errors) ==== + Iterator.zip("ab"); + ~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type 'string' is not assignable to parameter of type 'Iterable> & object'. +!!! error TS2769: Type 'string' is not assignable to type 'Iterable>'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + Iterator.zip(["ab"]); + ~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type 'string[]' is not assignable to parameter of type 'Iterable> & object'. +!!! error TS2769: Type 'string[]' is not assignable to type 'Iterable>'. +!!! error TS2769: The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. +!!! error TS2769: Type 'IteratorResult' is not assignable to type 'IteratorResult, any>'. +!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>'. +!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>'. +!!! error TS2769: Type 'string' is not assignable to type 'IteratorInput'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + Iterator.zip(new Set(["ab"])); + ~~~~~~~~~~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type 'Set' is not assignable to parameter of type 'Iterable> & object'. +!!! error TS2769: Type 'Set' is not assignable to type 'Iterable>'. +!!! error TS2769: The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. +!!! error TS2769: Type 'IteratorResult' is not assignable to type 'IteratorResult, any>'. +!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>'. +!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>'. +!!! error TS2769: Type 'string' is not assignable to type 'IteratorInput'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + Iterator.zipKeyed("ab"); + ~~~~ +!!! error TS2345: Argument of type 'string' is not assignable to parameter of type 'object & IteratorZipKeyedInput'. +!!! error TS2345: Type 'string' is not assignable to type 'object'. + Iterator.zipKeyed({ a: "ab" }); + ~ +!!! error TS2322: Type 'string' is not assignable to type 'never'. +!!! related TS6500 iteratorZipInputs.ts:5:21: The expected type comes from property 'a' which is declared here on type '{ a: string; } & IteratorZipKeyedInput<{ a: string; }>' + Iterator.zip([], { mode: "longest", padding: "ab" }); + ~~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Type 'string' is not assignable to type 'Iterable & object'. +!!! error TS2769: Type 'string' is not assignable to type 'Iterable'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); + ~~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Type 'string' is not assignable to type 'Iterable & object'. +!!! error TS2769: Type 'string' is not assignable to type 'object'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); + ~~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Type 'string' is not assignable to type 'object'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + + const a: [string][] = Iterator.zip([new String("ab")]).toArray(); + const b: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); + const c: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); + + const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); + const e: { a: number; }[] = d; + d[0].b; + ~ +!!! error TS2339: Property 'b' does not exist on type 'IteratorZipResult<{ a: number[]; } & {}, never, {}>'. + const f: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); + const g: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); + + interface I { + readonly a: Iterable; + readonly b?: Iterator; + readonly c: Iterable | undefined; + readonly d?: undefined; + } + declare const h: I; + const i = Iterator.zipKeyed(h).toArray(); + const j: { a: number; b?: string; c?: boolean; }[] = i; + i[0].a = 2; + i[0].b = "a"; + i[0].c = true; + i[0].d; + ~ +!!! error TS2339: Property 'd' does not exist on type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator | undefined; readonly c?: Iterable | undefined; }, never, {}>'. + const k: { a: number; c: boolean; }[] = i; + ~ +!!! error TS2322: Type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator | undefined; readonly c?: Iterable | undefined; }, never, {}>[]' is not assignable to type '{ a: number; c: boolean; }[]'. +!!! error TS2322: Type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator | undefined; readonly c?: Iterable | undefined; }, never, {}>' is not assignable to type '{ a: number; c: boolean; }'. +!!! error TS2322: Types of property 'c' are incompatible. +!!! error TS2322: Type 'boolean | undefined' is not assignable to type 'boolean'. +!!! error TS2322: Type 'undefined' is not assignable to type 'boolean'. + const l: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); + + declare const m: { a: Iterable; } | { b: Iterator; }; + const n: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(m).toArray(); + declare const o: { a: Iterable; } | { b: number; }; + Iterator.zipKeyed(o); + ~ +!!! error TS2345: Argument of type '{ a: Iterable; } | { b: number; }' is not assignable to parameter of type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. +!!! error TS2345: Type '{ b: number; }' is not assignable to type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. +!!! error TS2345: Type '{ b: number; }' is not assignable to type '{ b: number; } & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. +!!! error TS2345: Type '{ b: number; }' is not assignable to type 'IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. +!!! error TS2345: Types of property 'b' are incompatible. +!!! error TS2345: Type 'number' is not assignable to type 'IteratorInput | undefined'. + Iterator.zipKeyed(o, { mode: "longest" }); + ~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type '{ a: Iterable; } | { b: number; }' is not assignable to parameter of type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. +!!! error TS2769: Type '{ b: number; }' is not assignable to type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. +!!! error TS2769: Type '{ b: number; }' is not assignable to type '{ b: number; } & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. +!!! error TS2769: Type '{ b: number; }' is not assignable to type 'IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. +!!! error TS2769: Types of property 'b' are incompatible. +!!! error TS2769: Type 'number' is not assignable to type 'IteratorInput | undefined'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + Iterator.zipKeyed(o, { mode: "longest", padding: {} }); + ~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type '{ a: Iterable; } | { b: number; }' is not assignable to parameter of type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. +!!! error TS2769: Type '{ b: number; }' is not assignable to type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. +!!! error TS2769: Type '{ b: number; }' is not assignable to type '{ b: number; } & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. +!!! error TS2769: Type '{ b: number; }' is not assignable to type 'IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. +!!! error TS2769: Types of property 'b' are incompatible. +!!! error TS2769: Type 'number' is not assignable to type 'IteratorInput | undefined'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + declare const p: { a?: Iterable; } | { b: string; }; + Iterator.zipKeyed(p); + ~ +!!! error TS2345: Argument of type '{ a?: Iterable | undefined; } | { b: string; }' is not assignable to parameter of type '({ a?: Iterable | undefined; } | { b: string; }) & IteratorZipKeyedInput<{ a?: Iterable | undefined; } | { b: string; }>'. +!!! error TS2345: Type '{ b: string; }' is not assignable to type '({ a?: Iterable | undefined; } | { b: string; }) & IteratorZipKeyedInput<{ a?: Iterable | undefined; } | { b: string; }>'. +!!! error TS2345: Type '{ b: string; }' is not assignable to type '{ b: string; } & IteratorZipKeyedInput<{ a?: Iterable | undefined; } | { b: string; }>'. +!!! error TS2345: Type '{ b: string; }' is not assignable to type 'IteratorZipKeyedInput<{ a?: Iterable | undefined; } | { b: string; }>'. +!!! error TS2345: Types of property 'b' are incompatible. +!!! error TS2345: Type 'string' is not assignable to type 'IteratorInput | undefined'. + declare const q: { a: Iterable; } | { b: undefined; }; + const r: { a: number; }[] = Iterator.zipKeyed(q).toArray(); + + declare const s: unique symbol; + declare const t: { a: Iterable; [s]?: Iterable; }; + const u: { a: number; [s]?: string; }[] = Iterator.zipKeyed(t).toArray(); + + Iterator.zipKeyed({ a: [1], b: null }); + ~ +!!! error TS2322: Type 'number[]' is not assignable to type 'never'. + ~ +!!! error TS2322: Type 'null' is not assignable to type 'never'. + Iterator.zipKeyed({ a: [1], b: false }); + ~ +!!! error TS2322: Type 'number[]' is not assignable to type 'never'. + ~ +!!! error TS2322: Type 'false' is not assignable to type 'never'. + Iterator.zip([undefined]); + ~~~~~~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type 'undefined[]' is not assignable to parameter of type 'Iterable> & object'. +!!! error TS2769: Type 'undefined[]' is not assignable to type 'Iterable>'. +!!! error TS2769: The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. +!!! error TS2769: Type 'IteratorResult' is not assignable to type 'IteratorResult, any>'. +!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>'. +!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>'. +!!! error TS2769: Type 'undefined' is not assignable to type 'IteratorInput'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + + declare const v: { a?: undefined; }; + const w: never[] = Iterator.zipKeyed(v).toArray(); + const x: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); + const y: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); + + function f1(a: Iterable) { + const b: { a: T; }[] = Iterator.zipKeyed({ a }).toArray(); + const c: [T][] = Iterator.zip([a]).toArray(); + return { b, c }; + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=false).js b/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=false).js new file mode 100644 index 0000000000000..565466b55ab2d --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=false).js @@ -0,0 +1,208 @@ +//// [tests/cases/compiler/iteratorZipInputs.ts] //// + +//// [iteratorZipInputs.ts] +Iterator.zip("ab"); +Iterator.zip(["ab"]); +Iterator.zip(new Set(["ab"])); +Iterator.zipKeyed("ab"); +Iterator.zipKeyed({ a: "ab" }); +Iterator.zip([], { mode: "longest", padding: "ab" }); +Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); +Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); + +const a: [string][] = Iterator.zip([new String("ab")]).toArray(); +const b: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); +const c: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); + +const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); +const e: { a: number; }[] = d; +d[0].b; +const f: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); +const g: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); + +interface I { + readonly a: Iterable; + readonly b?: Iterator; + readonly c: Iterable | undefined; + readonly d?: undefined; +} +declare const h: I; +const i = Iterator.zipKeyed(h).toArray(); +const j: { a: number; b?: string; c?: boolean; }[] = i; +i[0].a = 2; +i[0].b = "a"; +i[0].c = true; +i[0].d; +const k: { a: number; c: boolean; }[] = i; +const l: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); + +declare const m: { a: Iterable; } | { b: Iterator; }; +const n: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(m).toArray(); +declare const o: { a: Iterable; } | { b: number; }; +Iterator.zipKeyed(o); +Iterator.zipKeyed(o, { mode: "longest" }); +Iterator.zipKeyed(o, { mode: "longest", padding: {} }); +declare const p: { a?: Iterable; } | { b: string; }; +Iterator.zipKeyed(p); +declare const q: { a: Iterable; } | { b: undefined; }; +const r: { a: number; }[] = Iterator.zipKeyed(q).toArray(); + +declare const s: unique symbol; +declare const t: { a: Iterable; [s]?: Iterable; }; +const u: { a: number; [s]?: string; }[] = Iterator.zipKeyed(t).toArray(); + +Iterator.zipKeyed({ a: [1], b: null }); +Iterator.zipKeyed({ a: [1], b: false }); +Iterator.zip([undefined]); + +declare const v: { a?: undefined; }; +const w: never[] = Iterator.zipKeyed(v).toArray(); +const x: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); +const y: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); + +function f1(a: Iterable) { + const b: { a: T; }[] = Iterator.zipKeyed({ a }).toArray(); + const c: [T][] = Iterator.zip([a]).toArray(); + return { b, c }; +} + + +//// [iteratorZipInputs.js] +"use strict"; +Iterator.zip("ab"); +Iterator.zip(["ab"]); +Iterator.zip(new Set(["ab"])); +Iterator.zipKeyed("ab"); +Iterator.zipKeyed({ a: "ab" }); +Iterator.zip([], { mode: "longest", padding: "ab" }); +Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); +Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); +const a = Iterator.zip([new String("ab")]).toArray(); +const b = Iterator.zipKeyed({ a: new String("ab") }).toArray(); +const c = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); +const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); +const e = d; +d[0].b; +const f = Iterator.zipKeyed({ a: undefined }).toArray(); +const g = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); +const i = Iterator.zipKeyed(h).toArray(); +const j = i; +i[0].a = 2; +i[0].b = "a"; +i[0].c = true; +i[0].d; +const k = i; +const l = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); +const n = Iterator.zipKeyed(m).toArray(); +Iterator.zipKeyed(o); +Iterator.zipKeyed(o, { mode: "longest" }); +Iterator.zipKeyed(o, { mode: "longest", padding: {} }); +Iterator.zipKeyed(p); +const r = Iterator.zipKeyed(q).toArray(); +const u = Iterator.zipKeyed(t).toArray(); +Iterator.zipKeyed({ a: [1], b: null }); +Iterator.zipKeyed({ a: [1], b: false }); +Iterator.zip([undefined]); +const w = Iterator.zipKeyed(v).toArray(); +const x = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); +const y = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); +function f1(a) { + const b = Iterator.zipKeyed({ a }).toArray(); + const c = Iterator.zip([a]).toArray(); + return { b, c }; +} + + +//// [iteratorZipInputs.d.ts] +declare const a: [string][]; +declare const b: { + a: string; +}[]; +declare const c: (string | undefined)[][]; +declare const d: { + a: number; +}[]; +declare const e: { + a: number; +}[]; +declare const f: never[]; +declare const g: never[]; +interface I { + readonly a: Iterable; + readonly b?: Iterator; + readonly c: Iterable | undefined; + readonly d?: undefined; +} +declare const h: I; +declare const i: { + a: number; + b?: string | undefined; + c?: boolean | undefined; +}[]; +declare const j: { + a: number; + b?: string; + c?: boolean; +}[]; +declare const k: { + a: number; + c: boolean; +}[]; +declare const l: { + a: number | undefined; + b?: string | undefined; + c?: boolean | undefined; +}[]; +declare const m: { + a: Iterable; +} | { + b: Iterator; +}; +declare const n: ({ + a: number; +} | { + b: string; +})[]; +declare const o: { + a: Iterable; +} | { + b: number; +}; +declare const p: { + a?: Iterable; +} | { + b: string; +}; +declare const q: { + a: Iterable; +} | { + b: undefined; +}; +declare const r: { + a: number; +}[]; +declare const s: unique symbol; +declare const t: { + a: Iterable; + [s]?: Iterable; +}; +declare const u: { + a: number; + [s]?: string; +}[]; +declare const v: { + a?: undefined; +}; +declare const w: never[]; +declare const x: { + a: number; +}[]; +declare const y: { + a: number | undefined; +}[]; +declare function f1(a: Iterable): { + b: { + a: T; + }[]; + c: [T][]; +}; diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=false).symbols b/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=false).symbols new file mode 100644 index 0000000000000..b9e998282517a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=false).symbols @@ -0,0 +1,388 @@ +//// [tests/cases/compiler/iteratorZipInputs.ts] //// + +=== iteratorZipInputs.ts === +Iterator.zip("ab"); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) + +Iterator.zip(["ab"]); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) + +Iterator.zip(new Set(["ab"])); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Set : Symbol(Set, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) + +Iterator.zipKeyed("ab"); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) + +Iterator.zipKeyed({ a: "ab" }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 4, 19)) + +Iterator.zip([], { mode: "longest", padding: "ab" }); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZipInputs.ts, 5, 18)) +>padding : Symbol(padding, Decl(iteratorZipInputs.ts, 5, 35)) + +Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZipInputs.ts, 6, 23)) +>padding : Symbol(padding, Decl(iteratorZipInputs.ts, 6, 40)) + +Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>mode : Symbol(mode, Decl(iteratorZipInputs.ts, 7, 23)) +>padding : Symbol(padding, Decl(iteratorZipInputs.ts, 7, 40)) + +const a: [string][] = Iterator.zip([new String("ab")]).toArray(); +>a : Symbol(a, Decl(iteratorZipInputs.ts, 9, 5)) +>Iterator.zip([new String("ab")]).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const b: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); +>b : Symbol(b, Decl(iteratorZipInputs.ts, 10, 5)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 10, 10)) +>Iterator.zipKeyed({ a: new String("ab") }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 10, 47)) +>String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const c: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); +>c : Symbol(c, Decl(iteratorZipInputs.ts, 11, 5)) +>Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZipInputs.ts, 11, 59)) +>padding : Symbol(padding, Decl(iteratorZipInputs.ts, 11, 76)) +>String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); +>d : Symbol(d, Decl(iteratorZipInputs.ts, 13, 5)) +>Iterator.zipKeyed({ a: [1], b: undefined }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 13, 29)) +>b : Symbol(b, Decl(iteratorZipInputs.ts, 13, 37)) +>undefined : Symbol(undefined) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const e: { a: number; }[] = d; +>e : Symbol(e, Decl(iteratorZipInputs.ts, 14, 5)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 14, 10)) +>d : Symbol(d, Decl(iteratorZipInputs.ts, 13, 5)) + +d[0].b; +>d : Symbol(d, Decl(iteratorZipInputs.ts, 13, 5)) + +const f: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); +>f : Symbol(f, Decl(iteratorZipInputs.ts, 16, 5)) +>Iterator.zipKeyed({ a: undefined }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 16, 38)) +>undefined : Symbol(undefined) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const g: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); +>g : Symbol(g, Decl(iteratorZipInputs.ts, 17, 5)) +>Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 17, 38)) +>undefined : Symbol(undefined) +>mode : Symbol(mode, Decl(iteratorZipInputs.ts, 17, 56)) +>padding : Symbol(padding, Decl(iteratorZipInputs.ts, 17, 73)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +interface I { +>I : Symbol(I, Decl(iteratorZipInputs.ts, 17, 99)) + + readonly a: Iterable; +>a : Symbol(I.a, Decl(iteratorZipInputs.ts, 19, 13)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + + readonly b?: Iterator; +>b : Symbol(I.b, Decl(iteratorZipInputs.ts, 20, 33)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) + + readonly c: Iterable | undefined; +>c : Symbol(I.c, Decl(iteratorZipInputs.ts, 21, 34)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + + readonly d?: undefined; +>d : Symbol(I.d, Decl(iteratorZipInputs.ts, 22, 46)) +} +declare const h: I; +>h : Symbol(h, Decl(iteratorZipInputs.ts, 25, 13)) +>I : Symbol(I, Decl(iteratorZipInputs.ts, 17, 99)) + +const i = Iterator.zipKeyed(h).toArray(); +>i : Symbol(i, Decl(iteratorZipInputs.ts, 26, 5)) +>Iterator.zipKeyed(h).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>h : Symbol(h, Decl(iteratorZipInputs.ts, 25, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const j: { a: number; b?: string; c?: boolean; }[] = i; +>j : Symbol(j, Decl(iteratorZipInputs.ts, 27, 5)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 27, 10)) +>b : Symbol(b, Decl(iteratorZipInputs.ts, 27, 21)) +>c : Symbol(c, Decl(iteratorZipInputs.ts, 27, 33)) +>i : Symbol(i, Decl(iteratorZipInputs.ts, 26, 5)) + +i[0].a = 2; +>i[0].a : Symbol(a, Decl(iteratorZipInputs.ts, 19, 13)) +>i : Symbol(i, Decl(iteratorZipInputs.ts, 26, 5)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 19, 13)) + +i[0].b = "a"; +>i[0].b : Symbol(b, Decl(iteratorZipInputs.ts, 20, 33)) +>i : Symbol(i, Decl(iteratorZipInputs.ts, 26, 5)) +>b : Symbol(b, Decl(iteratorZipInputs.ts, 20, 33)) + +i[0].c = true; +>i[0].c : Symbol(c, Decl(iteratorZipInputs.ts, 21, 34)) +>i : Symbol(i, Decl(iteratorZipInputs.ts, 26, 5)) +>c : Symbol(c, Decl(iteratorZipInputs.ts, 21, 34)) + +i[0].d; +>i : Symbol(i, Decl(iteratorZipInputs.ts, 26, 5)) + +const k: { a: number; c: boolean; }[] = i; +>k : Symbol(k, Decl(iteratorZipInputs.ts, 32, 5)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 32, 10)) +>c : Symbol(c, Decl(iteratorZipInputs.ts, 32, 21)) +>i : Symbol(i, Decl(iteratorZipInputs.ts, 26, 5)) + +const l: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); +>l : Symbol(l, Decl(iteratorZipInputs.ts, 33, 5)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 33, 10)) +>b : Symbol(b, Decl(iteratorZipInputs.ts, 33, 33)) +>c : Symbol(c, Decl(iteratorZipInputs.ts, 33, 57)) +>Iterator.zipKeyed(h, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>h : Symbol(h, Decl(iteratorZipInputs.ts, 25, 13)) +>mode : Symbol(mode, Decl(iteratorZipInputs.ts, 33, 111)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const m: { a: Iterable; } | { b: Iterator; }; +>m : Symbol(m, Decl(iteratorZipInputs.ts, 35, 13)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 35, 18)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>b : Symbol(b, Decl(iteratorZipInputs.ts, 35, 45)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) + +const n: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(m).toArray(); +>n : Symbol(n, Decl(iteratorZipInputs.ts, 36, 5)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 36, 11)) +>b : Symbol(b, Decl(iteratorZipInputs.ts, 36, 28)) +>Iterator.zipKeyed(m).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>m : Symbol(m, Decl(iteratorZipInputs.ts, 35, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const o: { a: Iterable; } | { b: number; }; +>o : Symbol(o, Decl(iteratorZipInputs.ts, 37, 13)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 37, 18)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>b : Symbol(b, Decl(iteratorZipInputs.ts, 37, 45)) + +Iterator.zipKeyed(o); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>o : Symbol(o, Decl(iteratorZipInputs.ts, 37, 13)) + +Iterator.zipKeyed(o, { mode: "longest" }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>o : Symbol(o, Decl(iteratorZipInputs.ts, 37, 13)) +>mode : Symbol(mode, Decl(iteratorZipInputs.ts, 39, 22)) + +Iterator.zipKeyed(o, { mode: "longest", padding: {} }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>o : Symbol(o, Decl(iteratorZipInputs.ts, 37, 13)) +>mode : Symbol(mode, Decl(iteratorZipInputs.ts, 40, 22)) +>padding : Symbol(padding, Decl(iteratorZipInputs.ts, 40, 39)) + +declare const p: { a?: Iterable; } | { b: string; }; +>p : Symbol(p, Decl(iteratorZipInputs.ts, 41, 13)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 41, 18)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>b : Symbol(b, Decl(iteratorZipInputs.ts, 41, 46)) + +Iterator.zipKeyed(p); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>p : Symbol(p, Decl(iteratorZipInputs.ts, 41, 13)) + +declare const q: { a: Iterable; } | { b: undefined; }; +>q : Symbol(q, Decl(iteratorZipInputs.ts, 43, 13)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 43, 18)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>b : Symbol(b, Decl(iteratorZipInputs.ts, 43, 45)) + +const r: { a: number; }[] = Iterator.zipKeyed(q).toArray(); +>r : Symbol(r, Decl(iteratorZipInputs.ts, 44, 5)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 44, 10)) +>Iterator.zipKeyed(q).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>q : Symbol(q, Decl(iteratorZipInputs.ts, 43, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const s: unique symbol; +>s : Symbol(s, Decl(iteratorZipInputs.ts, 46, 13)) + +declare const t: { a: Iterable; [s]?: Iterable; }; +>t : Symbol(t, Decl(iteratorZipInputs.ts, 47, 13)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 47, 18)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>[s] : Symbol([s], Decl(iteratorZipInputs.ts, 47, 39)) +>s : Symbol(s, Decl(iteratorZipInputs.ts, 46, 13)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + +const u: { a: number; [s]?: string; }[] = Iterator.zipKeyed(t).toArray(); +>u : Symbol(u, Decl(iteratorZipInputs.ts, 48, 5)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 48, 10)) +>[s] : Symbol([s], Decl(iteratorZipInputs.ts, 48, 21)) +>s : Symbol(s, Decl(iteratorZipInputs.ts, 46, 13)) +>Iterator.zipKeyed(t).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>t : Symbol(t, Decl(iteratorZipInputs.ts, 47, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +Iterator.zipKeyed({ a: [1], b: null }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 50, 19)) +>b : Symbol(b, Decl(iteratorZipInputs.ts, 50, 27)) + +Iterator.zipKeyed({ a: [1], b: false }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 51, 19)) +>b : Symbol(b, Decl(iteratorZipInputs.ts, 51, 27)) + +Iterator.zip([undefined]); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>undefined : Symbol(undefined) + +declare const v: { a?: undefined; }; +>v : Symbol(v, Decl(iteratorZipInputs.ts, 54, 13)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 54, 18)) + +const w: never[] = Iterator.zipKeyed(v).toArray(); +>w : Symbol(w, Decl(iteratorZipInputs.ts, 55, 5)) +>Iterator.zipKeyed(v).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>v : Symbol(v, Decl(iteratorZipInputs.ts, 54, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const x: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); +>x : Symbol(x, Decl(iteratorZipInputs.ts, 56, 5)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 56, 10)) +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 56, 47)) +>b : Symbol(b, Decl(iteratorZipInputs.ts, 56, 55)) +>undefined : Symbol(undefined) +>mode : Symbol(mode, Decl(iteratorZipInputs.ts, 56, 73)) +>padding : Symbol(padding, Decl(iteratorZipInputs.ts, 56, 90)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 56, 101)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const y: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); +>y : Symbol(y, Decl(iteratorZipInputs.ts, 57, 5)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 57, 10)) +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 57, 59)) +>b : Symbol(b, Decl(iteratorZipInputs.ts, 57, 67)) +>undefined : Symbol(undefined) +>mode : Symbol(mode, Decl(iteratorZipInputs.ts, 57, 85)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +function f1(a: Iterable) { +>f1 : Symbol(f1, Decl(iteratorZipInputs.ts, 57, 115)) +>T : Symbol(T, Decl(iteratorZipInputs.ts, 59, 12)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 59, 15)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>T : Symbol(T, Decl(iteratorZipInputs.ts, 59, 12)) + + const b: { a: T; }[] = Iterator.zipKeyed({ a }).toArray(); +>b : Symbol(b, Decl(iteratorZipInputs.ts, 60, 9)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 60, 14)) +>T : Symbol(T, Decl(iteratorZipInputs.ts, 59, 12)) +>Iterator.zipKeyed({ a }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 60, 46)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + + const c: [T][] = Iterator.zip([a]).toArray(); +>c : Symbol(c, Decl(iteratorZipInputs.ts, 61, 9)) +>T : Symbol(T, Decl(iteratorZipInputs.ts, 59, 12)) +>Iterator.zip([a]).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 59, 15)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + + return { b, c }; +>b : Symbol(b, Decl(iteratorZipInputs.ts, 62, 12)) +>c : Symbol(c, Decl(iteratorZipInputs.ts, 62, 15)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=false).types b/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=false).types new file mode 100644 index 0000000000000..0506f0c4acbf8 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=false).types @@ -0,0 +1,511 @@ +//// [tests/cases/compiler/iteratorZipInputs.ts] //// + +=== iteratorZipInputs.ts === +Iterator.zip("ab"); +>Iterator.zip("ab") : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>"ab" : "ab" + +Iterator.zip(["ab"]); +>Iterator.zip(["ab"]) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>["ab"] : [string] +>"ab" : "ab" + +Iterator.zip(new Set(["ab"])); +>Iterator.zip(new Set(["ab"])) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>new Set(["ab"]) : Set +>Set : SetConstructor +>["ab"] : string[] +>"ab" : "ab" + +Iterator.zipKeyed("ab"); +>Iterator.zipKeyed("ab") : IteratorObject +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>"ab" : "ab" + +Iterator.zipKeyed({ a: "ab" }); +>Iterator.zipKeyed({ a: "ab" }) : IteratorObject<{ a: never; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>{ a: "ab" } : { a: string; } +>a : string +>"ab" : "ab" + +Iterator.zip([], { mode: "longest", padding: "ab" }); +>Iterator.zip([], { mode: "longest", padding: "ab" }) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[] : [] +>{ mode: "longest", padding: "ab" } : { mode: "longest"; padding: string; } +>mode : "longest" +>"longest" : "longest" +>padding : string +>"ab" : "ab" + +Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); +>Iterator.zip([["a"]], { mode: "longest", padding: "ab" }) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[["a"]] : [string[]] +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: "ab" } : { mode: "longest"; padding: string; } +>mode : "longest" +>"longest" : "longest" +>padding : string +>"ab" : "ab" + +Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); +>Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }) : IteratorObject +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>{} : {} +>{ mode: "longest", padding: "ab" } : { mode: "longest"; padding: string; } +>mode : "longest" +>"longest" : "longest" +>padding : string +>"ab" : "ab" + +const a: [string][] = Iterator.zip([new String("ab")]).toArray(); +>a : [string][] +>Iterator.zip([new String("ab")]).toArray() : [string][] +>Iterator.zip([new String("ab")]).toArray : () => [string][] +>Iterator.zip([new String("ab")]) : IteratorObject<[string], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[new String("ab")] : [String] +>new String("ab") : String +>String : StringConstructor +>"ab" : "ab" +>toArray : () => [string][] + +const b: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); +>b : { a: string; }[] +>a : string +>Iterator.zipKeyed({ a: new String("ab") }).toArray() : { a: string; }[] +>Iterator.zipKeyed({ a: new String("ab") }).toArray : () => { a: string; }[] +>Iterator.zipKeyed({ a: new String("ab") }) : IteratorObject<{ a: string; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>{ a: new String("ab") } : { a: String; } +>a : String +>new String("ab") : String +>String : StringConstructor +>"ab" : "ab" +>toArray : () => { a: string; }[] + +const c: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); +>c : (string | undefined)[][] +>Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray() : (string | undefined)[][] +>Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray : () => (string | undefined)[][] +>Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }) : IteratorObject<(string | undefined)[], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[["a"]] : string[][] +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: new String("ab") } : { mode: "longest"; padding: String; } +>mode : "longest" +>"longest" : "longest" +>padding : String +>new String("ab") : String +>String : StringConstructor +>"ab" : "ab" +>toArray : () => (string | undefined)[][] + +const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); +>d : { a: number; }[] +>Iterator.zipKeyed({ a: [1], b: undefined }).toArray() : { a: number; }[] +>Iterator.zipKeyed({ a: [1], b: undefined }).toArray : () => { a: number; }[] +>Iterator.zipKeyed({ a: [1], b: undefined }) : IteratorObject<{ a: number; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>{ a: [1], b: undefined } : { a: number[]; b: undefined; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : undefined +>undefined : undefined +>toArray : () => { a: number; }[] + +const e: { a: number; }[] = d; +>e : { a: number; }[] +>a : number +>d : { a: number; }[] + +d[0].b; +>d[0].b : any +>d[0] : { a: number; } +>d : { a: number; }[] +>0 : 0 +>b : any + +const f: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); +>f : never[] +>Iterator.zipKeyed({ a: undefined }).toArray() : never[] +>Iterator.zipKeyed({ a: undefined }).toArray : () => never[] +>Iterator.zipKeyed({ a: undefined }) : IteratorObject +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>{ a: undefined } : { a: undefined; } +>a : undefined +>undefined : undefined +>toArray : () => never[] + +const g: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); +>g : never[] +>Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray() : never[] +>Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray : () => never[] +>Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }) : IteratorObject +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>{ a: undefined } : { a: undefined; } +>a : undefined +>undefined : undefined +>{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } +>mode : "longest" +>"longest" : "longest" +>padding : {} +>{} : {} +>toArray : () => never[] + +interface I { + readonly a: Iterable; +>a : Iterable + + readonly b?: Iterator; +>b : Iterator | undefined + + readonly c: Iterable | undefined; +>c : Iterable | undefined + + readonly d?: undefined; +>d : undefined +} +declare const h: I; +>h : I + +const i = Iterator.zipKeyed(h).toArray(); +>i : { a: number; b?: string | undefined; c?: boolean | undefined; }[] +>Iterator.zipKeyed(h).toArray() : { a: number; b?: string | undefined; c?: boolean | undefined; }[] +>Iterator.zipKeyed(h).toArray : () => { a: number; b?: string | undefined; c?: boolean | undefined; }[] +>Iterator.zipKeyed(h) : IteratorObject<{ a: number; b?: string | undefined; c?: boolean | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>h : I +>toArray : () => { a: number; b?: string | undefined; c?: boolean | undefined; }[] + +const j: { a: number; b?: string; c?: boolean; }[] = i; +>j : { a: number; b?: string; c?: boolean; }[] +>a : number +>b : string | undefined +>c : boolean | undefined +>i : { a: number; b?: string | undefined; c?: boolean | undefined; }[] + +i[0].a = 2; +>i[0].a = 2 : 2 +>i[0].a : number +>i[0] : { a: number; b?: string | undefined; c?: boolean | undefined; } +>i : { a: number; b?: string | undefined; c?: boolean | undefined; }[] +>0 : 0 +>a : number +>2 : 2 + +i[0].b = "a"; +>i[0].b = "a" : "a" +>i[0].b : string | undefined +>i[0] : { a: number; b?: string | undefined; c?: boolean | undefined; } +>i : { a: number; b?: string | undefined; c?: boolean | undefined; }[] +>0 : 0 +>b : string | undefined +>"a" : "a" + +i[0].c = true; +>i[0].c = true : true +>i[0].c : boolean | undefined +>i[0] : { a: number; b?: string | undefined; c?: boolean | undefined; } +>i : { a: number; b?: string | undefined; c?: boolean | undefined; }[] +>0 : 0 +>c : boolean | undefined +>true : true + +i[0].d; +>i[0].d : any +>i[0] : { a: number; b?: string | undefined; c?: boolean | undefined; } +>i : { a: number; b?: string | undefined; c?: boolean | undefined; }[] +>0 : 0 +>d : any + +const k: { a: number; c: boolean; }[] = i; +>k : { a: number; c: boolean; }[] +>a : number +>c : boolean +>i : { a: number; b?: string | undefined; c?: boolean | undefined; }[] + +const l: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); +>l : { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] +>a : number | undefined +>b : string | undefined +>c : boolean | undefined +>Iterator.zipKeyed(h, { mode: "longest" }).toArray() : { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] +>Iterator.zipKeyed(h, { mode: "longest" }).toArray : () => { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] +>Iterator.zipKeyed(h, { mode: "longest" }) : IteratorObject<{ a: number | undefined; b?: string | undefined; c?: boolean | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>h : I +>{ mode: "longest" } : { mode: "longest"; } +>mode : "longest" +>"longest" : "longest" +>toArray : () => { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] + +declare const m: { a: Iterable; } | { b: Iterator; }; +>m : { a: Iterable; } | { b: Iterator; } +>a : Iterable +>b : Iterator + +const n: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(m).toArray(); +>n : ({ a: number; } | { b: string; })[] +>a : number +>b : string +>Iterator.zipKeyed(m).toArray() : ({ a: number; } | { b: string; })[] +>Iterator.zipKeyed(m).toArray : () => ({ a: number; } | { b: string; })[] +>Iterator.zipKeyed(m) : IteratorObject<{ a: number; } | { b: string; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>m : { a: Iterable; } | { b: Iterator; } +>toArray : () => ({ a: number; } | { b: string; })[] + +declare const o: { a: Iterable; } | { b: number; }; +>o : { a: Iterable; } | { b: number; } +>a : Iterable +>b : number + +Iterator.zipKeyed(o); +>Iterator.zipKeyed(o) : IteratorObject<{ a: number; } | { b: never; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>o : { a: Iterable; } | { b: number; } + +Iterator.zipKeyed(o, { mode: "longest" }); +>Iterator.zipKeyed(o, { mode: "longest" }) : IteratorObject<{ a: number; } | { b: never; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>o : { a: Iterable; } | { b: number; } +>{ mode: "longest" } : { mode: "longest"; } +>mode : "longest" +>"longest" : "longest" + +Iterator.zipKeyed(o, { mode: "longest", padding: {} }); +>Iterator.zipKeyed(o, { mode: "longest", padding: {} }) : IteratorObject<{ a: number; } | { b: never; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>o : { a: Iterable; } | { b: number; } +>{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } +>mode : "longest" +>"longest" : "longest" +>padding : {} +>{} : {} + +declare const p: { a?: Iterable; } | { b: string; }; +>p : { a?: Iterable; } | { b: string; } +>a : Iterable | undefined +>b : string + +Iterator.zipKeyed(p); +>Iterator.zipKeyed(p) : IteratorObject<{ a?: number | undefined; } | { b: never; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>p : { a?: Iterable; } | { b: string; } + +declare const q: { a: Iterable; } | { b: undefined; }; +>q : { a: Iterable; } | { b: undefined; } +>a : Iterable +>b : undefined + +const r: { a: number; }[] = Iterator.zipKeyed(q).toArray(); +>r : { a: number; }[] +>a : number +>Iterator.zipKeyed(q).toArray() : { a: number; }[] +>Iterator.zipKeyed(q).toArray : () => { a: number; }[] +>Iterator.zipKeyed(q) : IteratorObject<{ a: number; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>q : { a: Iterable; } | { b: undefined; } +>toArray : () => { a: number; }[] + +declare const s: unique symbol; +>s : unique symbol + +declare const t: { a: Iterable; [s]?: Iterable; }; +>t : { a: Iterable; [s]?: Iterable; } +>a : Iterable +>[s] : Iterable | undefined +>s : unique symbol + +const u: { a: number; [s]?: string; }[] = Iterator.zipKeyed(t).toArray(); +>u : { a: number; [s]?: string; }[] +>a : number +>[s] : string | undefined +>s : unique symbol +>Iterator.zipKeyed(t).toArray() : { a: number; [s]?: string | undefined; }[] +>Iterator.zipKeyed(t).toArray : () => { a: number; [s]?: string | undefined; }[] +>Iterator.zipKeyed(t) : IteratorObject<{ a: number; [s]?: string | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>t : { a: Iterable; [s]?: Iterable; } +>toArray : () => { a: number; [s]?: string | undefined; }[] + +Iterator.zipKeyed({ a: [1], b: null }); +>Iterator.zipKeyed({ a: [1], b: null }) : IteratorObject<{ a: number; b: never; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>{ a: [1], b: null } : { a: number[]; b: null; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : null + +Iterator.zipKeyed({ a: [1], b: false }); +>Iterator.zipKeyed({ a: [1], b: false }) : IteratorObject<{ a: number; b: never; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>{ a: [1], b: false } : { a: number[]; b: boolean; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : boolean +>false : false + +Iterator.zip([undefined]); +>Iterator.zip([undefined]) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[undefined] : [undefined] +>undefined : undefined + +declare const v: { a?: undefined; }; +>v : { a?: undefined; } +>a : undefined + +const w: never[] = Iterator.zipKeyed(v).toArray(); +>w : never[] +>Iterator.zipKeyed(v).toArray() : never[] +>Iterator.zipKeyed(v).toArray : () => never[] +>Iterator.zipKeyed(v) : IteratorObject +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>v : { a?: undefined; } +>toArray : () => never[] + +const x: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); +>x : { a: number; }[] +>a : number +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray() : { a: number; }[] +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray : () => { a: number; }[] +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }) : IteratorObject<{ a: number; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>{ a: [1], b: undefined } : { a: number[]; b: undefined; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : undefined +>undefined : undefined +>{ mode: "longest", padding: { a: 0 } } : { mode: "longest"; padding: { a: number; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: number; } +>{ a: 0 } : { a: number; } +>a : number +>0 : 0 +>toArray : () => { a: number; }[] + +const y: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); +>y : { a: number | undefined; }[] +>a : number | undefined +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray() : { a: number | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray : () => { a: number | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }) : IteratorObject<{ a: number | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>{ a: [1], b: undefined } : { a: number[]; b: undefined; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : undefined +>undefined : undefined +>{ mode: "longest" } : { mode: "longest"; } +>mode : "longest" +>"longest" : "longest" +>toArray : () => { a: number | undefined; }[] + +function f1(a: Iterable) { +>f1 : (a: Iterable) => { b: { a: T; }[]; c: [T][]; } +>a : Iterable + + const b: { a: T; }[] = Iterator.zipKeyed({ a }).toArray(); +>b : { a: T; }[] +>a : T +>Iterator.zipKeyed({ a }).toArray() : { a: T; }[] +>Iterator.zipKeyed({ a }).toArray : () => { a: T; }[] +>Iterator.zipKeyed({ a }) : IteratorObject<{ a: T; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K] | undefined; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K] | undefined; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K] | undefined; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K] | undefined; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K] | undefined; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K] | undefined; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>{ a } : { a: Iterable; } +>a : Iterable +>toArray : () => { a: T; }[] + + const c: [T][] = Iterator.zip([a]).toArray(); +>c : [T][] +>Iterator.zip([a]).toArray() : [T][] +>Iterator.zip([a]).toArray : () => [T][] +>Iterator.zip([a]) : IteratorObject<[T], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T_1, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T_1, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T_1, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T_1 extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T_1 extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T_1, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T_1, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T_1, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T_1 extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T_1 extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[a] : [Iterable] +>a : Iterable +>toArray : () => [T][] + + return { b, c }; +>{ b, c } : { b: { a: T; }[]; c: [T][]; } +>b : { a: T; }[] +>c : [T][] +} + diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=true).errors.txt b/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=true).errors.txt new file mode 100644 index 0000000000000..129663dd36d57 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=true).errors.txt @@ -0,0 +1,262 @@ +iteratorZipInputs.ts(1,14): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type 'string' is not assignable to parameter of type 'Iterable> & object'. + Type 'string' is not assignable to type 'Iterable>'. +iteratorZipInputs.ts(2,14): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type 'string[]' is not assignable to parameter of type 'Iterable> & object'. + Type 'string[]' is not assignable to type 'Iterable>'. + The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. + Type 'IteratorResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. + Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. + Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. + Type 'string' is not assignable to type 'IteratorInput'. +iteratorZipInputs.ts(3,14): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type 'Set' is not assignable to parameter of type 'Iterable> & object'. + Type 'Set' is not assignable to type 'Iterable>'. + The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. + Type 'IteratorResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. + Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. + Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. + Type 'string' is not assignable to type 'IteratorInput'. +iteratorZipInputs.ts(4,19): error TS2345: Argument of type 'string' is not assignable to parameter of type 'object & IteratorZipKeyedInput'. + Type 'string' is not assignable to type 'object'. +iteratorZipInputs.ts(5,21): error TS2322: Type 'string' is not assignable to type 'never'. +iteratorZipInputs.ts(6,37): error TS2769: No overload matches this call. + The last overload gave the following error. + Type 'string' is not assignable to type 'Iterable & object'. + Type 'string' is not assignable to type 'Iterable'. +iteratorZipInputs.ts(7,42): error TS2769: No overload matches this call. + The last overload gave the following error. + Type 'string' is not assignable to type 'Iterable & object'. + Type 'string' is not assignable to type 'object'. +iteratorZipInputs.ts(8,42): error TS2769: No overload matches this call. + The last overload gave the following error. + Type 'string' is not assignable to type 'object'. +iteratorZipInputs.ts(16,6): error TS2339: Property 'b' does not exist on type 'IteratorZipResult<{ a: number[]; } & {}, never, {}>'. +iteratorZipInputs.ts(32,6): error TS2339: Property 'd' does not exist on type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator; readonly c?: Iterable | undefined; }, never, {}>'. +iteratorZipInputs.ts(33,7): error TS2322: Type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator; readonly c?: Iterable | undefined; }, never, {}>[]' is not assignable to type '{ a: number; c: boolean; }[]'. + Type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator; readonly c?: Iterable | undefined; }, never, {}>' is not assignable to type '{ a: number; c: boolean; }'. + Property 'c' is optional in type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator; readonly c?: Iterable | undefined; }, never, {}>' but required in type '{ a: number; c: boolean; }'. +iteratorZipInputs.ts(39,19): error TS2345: Argument of type '{ a: Iterable; } | { b: number; }' is not assignable to parameter of type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. + Type '{ b: number; }' is not assignable to type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. + Type '{ b: number; }' is not assignable to type '{ b: number; } & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. + Type '{ b: number; }' is not assignable to type 'IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. + Types of property 'b' are incompatible. + Type 'number' is not assignable to type 'IteratorInput | undefined'. +iteratorZipInputs.ts(40,19): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type '{ a: Iterable; } | { b: number; }' is not assignable to parameter of type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. + Type '{ b: number; }' is not assignable to type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. + Type '{ b: number; }' is not assignable to type '{ b: number; } & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. + Type '{ b: number; }' is not assignable to type 'IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. + Types of property 'b' are incompatible. + Type 'number' is not assignable to type 'IteratorInput | undefined'. +iteratorZipInputs.ts(41,19): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type '{ a: Iterable; } | { b: number; }' is not assignable to parameter of type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. + Type '{ b: number; }' is not assignable to type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. + Type '{ b: number; }' is not assignable to type '{ b: number; } & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. + Type '{ b: number; }' is not assignable to type 'IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. + Types of property 'b' are incompatible. + Type 'number' is not assignable to type 'IteratorInput | undefined'. +iteratorZipInputs.ts(43,19): error TS2345: Argument of type '{ a?: Iterable; } | { b: string; }' is not assignable to parameter of type '({ a?: Iterable; } | { b: string; }) & IteratorZipKeyedInput<{ a?: Iterable; } | { b: string; }>'. + Type '{ b: string; }' is not assignable to type '({ a?: Iterable; } | { b: string; }) & IteratorZipKeyedInput<{ a?: Iterable; } | { b: string; }>'. + Type '{ b: string; }' is not assignable to type '{ b: string; } & IteratorZipKeyedInput<{ a?: Iterable; } | { b: string; }>'. + Type '{ b: string; }' is not assignable to type 'IteratorZipKeyedInput<{ a?: Iterable; } | { b: string; }>'. + Types of property 'b' are incompatible. + Type 'string' is not assignable to type 'IteratorInput | undefined'. +iteratorZipInputs.ts(51,21): error TS2322: Type 'number[]' is not assignable to type 'never'. +iteratorZipInputs.ts(51,29): error TS2322: Type 'null' is not assignable to type 'never'. +iteratorZipInputs.ts(52,21): error TS2322: Type 'number[]' is not assignable to type 'never'. +iteratorZipInputs.ts(52,29): error TS2322: Type 'false' is not assignable to type 'never'. +iteratorZipInputs.ts(53,14): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type 'undefined[]' is not assignable to parameter of type 'Iterable> & object'. + Type 'undefined[]' is not assignable to type 'Iterable>'. + The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. + Type 'IteratorResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. + Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. + Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. + Type 'undefined' is not assignable to type 'IteratorInput'. + + +==== iteratorZipInputs.ts (20 errors) ==== + Iterator.zip("ab"); + ~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type 'string' is not assignable to parameter of type 'Iterable> & object'. +!!! error TS2769: Type 'string' is not assignable to type 'Iterable>'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + Iterator.zip(["ab"]); + ~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type 'string[]' is not assignable to parameter of type 'Iterable> & object'. +!!! error TS2769: Type 'string[]' is not assignable to type 'Iterable>'. +!!! error TS2769: The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. +!!! error TS2769: Type 'IteratorResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. +!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. +!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. +!!! error TS2769: Type 'string' is not assignable to type 'IteratorInput'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + Iterator.zip(new Set(["ab"])); + ~~~~~~~~~~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type 'Set' is not assignable to parameter of type 'Iterable> & object'. +!!! error TS2769: Type 'Set' is not assignable to type 'Iterable>'. +!!! error TS2769: The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. +!!! error TS2769: Type 'IteratorResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. +!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. +!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. +!!! error TS2769: Type 'string' is not assignable to type 'IteratorInput'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + Iterator.zipKeyed("ab"); + ~~~~ +!!! error TS2345: Argument of type 'string' is not assignable to parameter of type 'object & IteratorZipKeyedInput'. +!!! error TS2345: Type 'string' is not assignable to type 'object'. + Iterator.zipKeyed({ a: "ab" }); + ~ +!!! error TS2322: Type 'string' is not assignable to type 'never'. +!!! related TS6500 iteratorZipInputs.ts:5:21: The expected type comes from property 'a' which is declared here on type '{ a: string; } & IteratorZipKeyedInput<{ a: string; }>' + Iterator.zip([], { mode: "longest", padding: "ab" }); + ~~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Type 'string' is not assignable to type 'Iterable & object'. +!!! error TS2769: Type 'string' is not assignable to type 'Iterable'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); + ~~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Type 'string' is not assignable to type 'Iterable & object'. +!!! error TS2769: Type 'string' is not assignable to type 'object'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); + ~~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Type 'string' is not assignable to type 'object'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + + const a: [string][] = Iterator.zip([new String("ab")]).toArray(); + const b: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); + const c: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); + + const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); + const e: { a: number; }[] = d; + d[0].b; + ~ +!!! error TS2339: Property 'b' does not exist on type 'IteratorZipResult<{ a: number[]; } & {}, never, {}>'. + const f: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); + const g: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); + + interface I { + readonly a: Iterable; + readonly b?: Iterator; + readonly c: Iterable | undefined; + readonly d?: undefined; + } + declare const h: I; + const i = Iterator.zipKeyed(h).toArray(); + const j: { a: number; b?: string; c?: boolean; }[] = i; + i[0].a = 2; + i[0].b = "a"; + i[0].c = true; + i[0].d; + ~ +!!! error TS2339: Property 'd' does not exist on type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator; readonly c?: Iterable | undefined; }, never, {}>'. + const k: { a: number; c: boolean; }[] = i; + ~ +!!! error TS2322: Type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator; readonly c?: Iterable | undefined; }, never, {}>[]' is not assignable to type '{ a: number; c: boolean; }[]'. +!!! error TS2322: Type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator; readonly c?: Iterable | undefined; }, never, {}>' is not assignable to type '{ a: number; c: boolean; }'. +!!! error TS2322: Property 'c' is optional in type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator; readonly c?: Iterable | undefined; }, never, {}>' but required in type '{ a: number; c: boolean; }'. + const l: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); + + declare const m: { a: Iterable; } | { b: Iterator; }; + const n: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(m).toArray(); + declare const o: { a: Iterable; } | { b: number; }; + Iterator.zipKeyed(o); + ~ +!!! error TS2345: Argument of type '{ a: Iterable; } | { b: number; }' is not assignable to parameter of type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. +!!! error TS2345: Type '{ b: number; }' is not assignable to type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. +!!! error TS2345: Type '{ b: number; }' is not assignable to type '{ b: number; } & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. +!!! error TS2345: Type '{ b: number; }' is not assignable to type 'IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. +!!! error TS2345: Types of property 'b' are incompatible. +!!! error TS2345: Type 'number' is not assignable to type 'IteratorInput | undefined'. + Iterator.zipKeyed(o, { mode: "longest" }); + ~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type '{ a: Iterable; } | { b: number; }' is not assignable to parameter of type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. +!!! error TS2769: Type '{ b: number; }' is not assignable to type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. +!!! error TS2769: Type '{ b: number; }' is not assignable to type '{ b: number; } & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. +!!! error TS2769: Type '{ b: number; }' is not assignable to type 'IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. +!!! error TS2769: Types of property 'b' are incompatible. +!!! error TS2769: Type 'number' is not assignable to type 'IteratorInput | undefined'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + Iterator.zipKeyed(o, { mode: "longest", padding: {} }); + ~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type '{ a: Iterable; } | { b: number; }' is not assignable to parameter of type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. +!!! error TS2769: Type '{ b: number; }' is not assignable to type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. +!!! error TS2769: Type '{ b: number; }' is not assignable to type '{ b: number; } & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. +!!! error TS2769: Type '{ b: number; }' is not assignable to type 'IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. +!!! error TS2769: Types of property 'b' are incompatible. +!!! error TS2769: Type 'number' is not assignable to type 'IteratorInput | undefined'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + declare const p: { a?: Iterable; } | { b: string; }; + Iterator.zipKeyed(p); + ~ +!!! error TS2345: Argument of type '{ a?: Iterable; } | { b: string; }' is not assignable to parameter of type '({ a?: Iterable; } | { b: string; }) & IteratorZipKeyedInput<{ a?: Iterable; } | { b: string; }>'. +!!! error TS2345: Type '{ b: string; }' is not assignable to type '({ a?: Iterable; } | { b: string; }) & IteratorZipKeyedInput<{ a?: Iterable; } | { b: string; }>'. +!!! error TS2345: Type '{ b: string; }' is not assignable to type '{ b: string; } & IteratorZipKeyedInput<{ a?: Iterable; } | { b: string; }>'. +!!! error TS2345: Type '{ b: string; }' is not assignable to type 'IteratorZipKeyedInput<{ a?: Iterable; } | { b: string; }>'. +!!! error TS2345: Types of property 'b' are incompatible. +!!! error TS2345: Type 'string' is not assignable to type 'IteratorInput | undefined'. + declare const q: { a: Iterable; } | { b: undefined; }; + const r: { a: number; }[] = Iterator.zipKeyed(q).toArray(); + + declare const s: unique symbol; + declare const t: { a: Iterable; [s]?: Iterable; }; + const u: { a: number; [s]?: string; }[] = Iterator.zipKeyed(t).toArray(); + + Iterator.zipKeyed({ a: [1], b: null }); + ~ +!!! error TS2322: Type 'number[]' is not assignable to type 'never'. + ~ +!!! error TS2322: Type 'null' is not assignable to type 'never'. + Iterator.zipKeyed({ a: [1], b: false }); + ~ +!!! error TS2322: Type 'number[]' is not assignable to type 'never'. + ~ +!!! error TS2322: Type 'false' is not assignable to type 'never'. + Iterator.zip([undefined]); + ~~~~~~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type 'undefined[]' is not assignable to parameter of type 'Iterable> & object'. +!!! error TS2769: Type 'undefined[]' is not assignable to type 'Iterable>'. +!!! error TS2769: The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. +!!! error TS2769: Type 'IteratorResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. +!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. +!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. +!!! error TS2769: Type 'undefined' is not assignable to type 'IteratorInput'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + + declare const v: { a?: undefined; }; + const w: never[] = Iterator.zipKeyed(v).toArray(); + const x: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); + const y: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); + + function f1(a: Iterable) { + const b: { a: T; }[] = Iterator.zipKeyed({ a }).toArray(); + const c: [T][] = Iterator.zip([a]).toArray(); + return { b, c }; + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=true).js b/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=true).js new file mode 100644 index 0000000000000..0db719cfcb44a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=true).js @@ -0,0 +1,208 @@ +//// [tests/cases/compiler/iteratorZipInputs.ts] //// + +//// [iteratorZipInputs.ts] +Iterator.zip("ab"); +Iterator.zip(["ab"]); +Iterator.zip(new Set(["ab"])); +Iterator.zipKeyed("ab"); +Iterator.zipKeyed({ a: "ab" }); +Iterator.zip([], { mode: "longest", padding: "ab" }); +Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); +Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); + +const a: [string][] = Iterator.zip([new String("ab")]).toArray(); +const b: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); +const c: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); + +const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); +const e: { a: number; }[] = d; +d[0].b; +const f: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); +const g: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); + +interface I { + readonly a: Iterable; + readonly b?: Iterator; + readonly c: Iterable | undefined; + readonly d?: undefined; +} +declare const h: I; +const i = Iterator.zipKeyed(h).toArray(); +const j: { a: number; b?: string; c?: boolean; }[] = i; +i[0].a = 2; +i[0].b = "a"; +i[0].c = true; +i[0].d; +const k: { a: number; c: boolean; }[] = i; +const l: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); + +declare const m: { a: Iterable; } | { b: Iterator; }; +const n: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(m).toArray(); +declare const o: { a: Iterable; } | { b: number; }; +Iterator.zipKeyed(o); +Iterator.zipKeyed(o, { mode: "longest" }); +Iterator.zipKeyed(o, { mode: "longest", padding: {} }); +declare const p: { a?: Iterable; } | { b: string; }; +Iterator.zipKeyed(p); +declare const q: { a: Iterable; } | { b: undefined; }; +const r: { a: number; }[] = Iterator.zipKeyed(q).toArray(); + +declare const s: unique symbol; +declare const t: { a: Iterable; [s]?: Iterable; }; +const u: { a: number; [s]?: string; }[] = Iterator.zipKeyed(t).toArray(); + +Iterator.zipKeyed({ a: [1], b: null }); +Iterator.zipKeyed({ a: [1], b: false }); +Iterator.zip([undefined]); + +declare const v: { a?: undefined; }; +const w: never[] = Iterator.zipKeyed(v).toArray(); +const x: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); +const y: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); + +function f1(a: Iterable) { + const b: { a: T; }[] = Iterator.zipKeyed({ a }).toArray(); + const c: [T][] = Iterator.zip([a]).toArray(); + return { b, c }; +} + + +//// [iteratorZipInputs.js] +"use strict"; +Iterator.zip("ab"); +Iterator.zip(["ab"]); +Iterator.zip(new Set(["ab"])); +Iterator.zipKeyed("ab"); +Iterator.zipKeyed({ a: "ab" }); +Iterator.zip([], { mode: "longest", padding: "ab" }); +Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); +Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); +const a = Iterator.zip([new String("ab")]).toArray(); +const b = Iterator.zipKeyed({ a: new String("ab") }).toArray(); +const c = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); +const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); +const e = d; +d[0].b; +const f = Iterator.zipKeyed({ a: undefined }).toArray(); +const g = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); +const i = Iterator.zipKeyed(h).toArray(); +const j = i; +i[0].a = 2; +i[0].b = "a"; +i[0].c = true; +i[0].d; +const k = i; +const l = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); +const n = Iterator.zipKeyed(m).toArray(); +Iterator.zipKeyed(o); +Iterator.zipKeyed(o, { mode: "longest" }); +Iterator.zipKeyed(o, { mode: "longest", padding: {} }); +Iterator.zipKeyed(p); +const r = Iterator.zipKeyed(q).toArray(); +const u = Iterator.zipKeyed(t).toArray(); +Iterator.zipKeyed({ a: [1], b: null }); +Iterator.zipKeyed({ a: [1], b: false }); +Iterator.zip([undefined]); +const w = Iterator.zipKeyed(v).toArray(); +const x = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); +const y = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); +function f1(a) { + const b = Iterator.zipKeyed({ a }).toArray(); + const c = Iterator.zip([a]).toArray(); + return { b, c }; +} + + +//// [iteratorZipInputs.d.ts] +declare const a: [string][]; +declare const b: { + a: string; +}[]; +declare const c: (string | undefined)[][]; +declare const d: { + a: number; +}[]; +declare const e: { + a: number; +}[]; +declare const f: never[]; +declare const g: never[]; +interface I { + readonly a: Iterable; + readonly b?: Iterator; + readonly c: Iterable | undefined; + readonly d?: undefined; +} +declare const h: I; +declare const i: { + a: number; + b?: string; + c?: boolean; +}[]; +declare const j: { + a: number; + b?: string; + c?: boolean; +}[]; +declare const k: { + a: number; + c: boolean; +}[]; +declare const l: { + a: number | undefined; + b?: string | undefined; + c?: boolean | undefined; +}[]; +declare const m: { + a: Iterable; +} | { + b: Iterator; +}; +declare const n: ({ + a: number; +} | { + b: string; +})[]; +declare const o: { + a: Iterable; +} | { + b: number; +}; +declare const p: { + a?: Iterable; +} | { + b: string; +}; +declare const q: { + a: Iterable; +} | { + b: undefined; +}; +declare const r: { + a: number; +}[]; +declare const s: unique symbol; +declare const t: { + a: Iterable; + [s]?: Iterable; +}; +declare const u: { + a: number; + [s]?: string; +}[]; +declare const v: { + a?: undefined; +}; +declare const w: never[]; +declare const x: { + a: number; +}[]; +declare const y: { + a: number | undefined; +}[]; +declare function f1(a: Iterable): { + b: { + a: T; + }[]; + c: [T][]; +}; diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=true).symbols b/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=true).symbols new file mode 100644 index 0000000000000..b9e998282517a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=true).symbols @@ -0,0 +1,388 @@ +//// [tests/cases/compiler/iteratorZipInputs.ts] //// + +=== iteratorZipInputs.ts === +Iterator.zip("ab"); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) + +Iterator.zip(["ab"]); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) + +Iterator.zip(new Set(["ab"])); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Set : Symbol(Set, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) + +Iterator.zipKeyed("ab"); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) + +Iterator.zipKeyed({ a: "ab" }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 4, 19)) + +Iterator.zip([], { mode: "longest", padding: "ab" }); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZipInputs.ts, 5, 18)) +>padding : Symbol(padding, Decl(iteratorZipInputs.ts, 5, 35)) + +Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZipInputs.ts, 6, 23)) +>padding : Symbol(padding, Decl(iteratorZipInputs.ts, 6, 40)) + +Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>mode : Symbol(mode, Decl(iteratorZipInputs.ts, 7, 23)) +>padding : Symbol(padding, Decl(iteratorZipInputs.ts, 7, 40)) + +const a: [string][] = Iterator.zip([new String("ab")]).toArray(); +>a : Symbol(a, Decl(iteratorZipInputs.ts, 9, 5)) +>Iterator.zip([new String("ab")]).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const b: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); +>b : Symbol(b, Decl(iteratorZipInputs.ts, 10, 5)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 10, 10)) +>Iterator.zipKeyed({ a: new String("ab") }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 10, 47)) +>String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const c: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); +>c : Symbol(c, Decl(iteratorZipInputs.ts, 11, 5)) +>Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZipInputs.ts, 11, 59)) +>padding : Symbol(padding, Decl(iteratorZipInputs.ts, 11, 76)) +>String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); +>d : Symbol(d, Decl(iteratorZipInputs.ts, 13, 5)) +>Iterator.zipKeyed({ a: [1], b: undefined }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 13, 29)) +>b : Symbol(b, Decl(iteratorZipInputs.ts, 13, 37)) +>undefined : Symbol(undefined) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const e: { a: number; }[] = d; +>e : Symbol(e, Decl(iteratorZipInputs.ts, 14, 5)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 14, 10)) +>d : Symbol(d, Decl(iteratorZipInputs.ts, 13, 5)) + +d[0].b; +>d : Symbol(d, Decl(iteratorZipInputs.ts, 13, 5)) + +const f: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); +>f : Symbol(f, Decl(iteratorZipInputs.ts, 16, 5)) +>Iterator.zipKeyed({ a: undefined }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 16, 38)) +>undefined : Symbol(undefined) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const g: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); +>g : Symbol(g, Decl(iteratorZipInputs.ts, 17, 5)) +>Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 17, 38)) +>undefined : Symbol(undefined) +>mode : Symbol(mode, Decl(iteratorZipInputs.ts, 17, 56)) +>padding : Symbol(padding, Decl(iteratorZipInputs.ts, 17, 73)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +interface I { +>I : Symbol(I, Decl(iteratorZipInputs.ts, 17, 99)) + + readonly a: Iterable; +>a : Symbol(I.a, Decl(iteratorZipInputs.ts, 19, 13)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + + readonly b?: Iterator; +>b : Symbol(I.b, Decl(iteratorZipInputs.ts, 20, 33)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) + + readonly c: Iterable | undefined; +>c : Symbol(I.c, Decl(iteratorZipInputs.ts, 21, 34)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + + readonly d?: undefined; +>d : Symbol(I.d, Decl(iteratorZipInputs.ts, 22, 46)) +} +declare const h: I; +>h : Symbol(h, Decl(iteratorZipInputs.ts, 25, 13)) +>I : Symbol(I, Decl(iteratorZipInputs.ts, 17, 99)) + +const i = Iterator.zipKeyed(h).toArray(); +>i : Symbol(i, Decl(iteratorZipInputs.ts, 26, 5)) +>Iterator.zipKeyed(h).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>h : Symbol(h, Decl(iteratorZipInputs.ts, 25, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const j: { a: number; b?: string; c?: boolean; }[] = i; +>j : Symbol(j, Decl(iteratorZipInputs.ts, 27, 5)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 27, 10)) +>b : Symbol(b, Decl(iteratorZipInputs.ts, 27, 21)) +>c : Symbol(c, Decl(iteratorZipInputs.ts, 27, 33)) +>i : Symbol(i, Decl(iteratorZipInputs.ts, 26, 5)) + +i[0].a = 2; +>i[0].a : Symbol(a, Decl(iteratorZipInputs.ts, 19, 13)) +>i : Symbol(i, Decl(iteratorZipInputs.ts, 26, 5)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 19, 13)) + +i[0].b = "a"; +>i[0].b : Symbol(b, Decl(iteratorZipInputs.ts, 20, 33)) +>i : Symbol(i, Decl(iteratorZipInputs.ts, 26, 5)) +>b : Symbol(b, Decl(iteratorZipInputs.ts, 20, 33)) + +i[0].c = true; +>i[0].c : Symbol(c, Decl(iteratorZipInputs.ts, 21, 34)) +>i : Symbol(i, Decl(iteratorZipInputs.ts, 26, 5)) +>c : Symbol(c, Decl(iteratorZipInputs.ts, 21, 34)) + +i[0].d; +>i : Symbol(i, Decl(iteratorZipInputs.ts, 26, 5)) + +const k: { a: number; c: boolean; }[] = i; +>k : Symbol(k, Decl(iteratorZipInputs.ts, 32, 5)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 32, 10)) +>c : Symbol(c, Decl(iteratorZipInputs.ts, 32, 21)) +>i : Symbol(i, Decl(iteratorZipInputs.ts, 26, 5)) + +const l: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); +>l : Symbol(l, Decl(iteratorZipInputs.ts, 33, 5)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 33, 10)) +>b : Symbol(b, Decl(iteratorZipInputs.ts, 33, 33)) +>c : Symbol(c, Decl(iteratorZipInputs.ts, 33, 57)) +>Iterator.zipKeyed(h, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>h : Symbol(h, Decl(iteratorZipInputs.ts, 25, 13)) +>mode : Symbol(mode, Decl(iteratorZipInputs.ts, 33, 111)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const m: { a: Iterable; } | { b: Iterator; }; +>m : Symbol(m, Decl(iteratorZipInputs.ts, 35, 13)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 35, 18)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>b : Symbol(b, Decl(iteratorZipInputs.ts, 35, 45)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) + +const n: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(m).toArray(); +>n : Symbol(n, Decl(iteratorZipInputs.ts, 36, 5)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 36, 11)) +>b : Symbol(b, Decl(iteratorZipInputs.ts, 36, 28)) +>Iterator.zipKeyed(m).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>m : Symbol(m, Decl(iteratorZipInputs.ts, 35, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const o: { a: Iterable; } | { b: number; }; +>o : Symbol(o, Decl(iteratorZipInputs.ts, 37, 13)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 37, 18)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>b : Symbol(b, Decl(iteratorZipInputs.ts, 37, 45)) + +Iterator.zipKeyed(o); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>o : Symbol(o, Decl(iteratorZipInputs.ts, 37, 13)) + +Iterator.zipKeyed(o, { mode: "longest" }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>o : Symbol(o, Decl(iteratorZipInputs.ts, 37, 13)) +>mode : Symbol(mode, Decl(iteratorZipInputs.ts, 39, 22)) + +Iterator.zipKeyed(o, { mode: "longest", padding: {} }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>o : Symbol(o, Decl(iteratorZipInputs.ts, 37, 13)) +>mode : Symbol(mode, Decl(iteratorZipInputs.ts, 40, 22)) +>padding : Symbol(padding, Decl(iteratorZipInputs.ts, 40, 39)) + +declare const p: { a?: Iterable; } | { b: string; }; +>p : Symbol(p, Decl(iteratorZipInputs.ts, 41, 13)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 41, 18)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>b : Symbol(b, Decl(iteratorZipInputs.ts, 41, 46)) + +Iterator.zipKeyed(p); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>p : Symbol(p, Decl(iteratorZipInputs.ts, 41, 13)) + +declare const q: { a: Iterable; } | { b: undefined; }; +>q : Symbol(q, Decl(iteratorZipInputs.ts, 43, 13)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 43, 18)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>b : Symbol(b, Decl(iteratorZipInputs.ts, 43, 45)) + +const r: { a: number; }[] = Iterator.zipKeyed(q).toArray(); +>r : Symbol(r, Decl(iteratorZipInputs.ts, 44, 5)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 44, 10)) +>Iterator.zipKeyed(q).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>q : Symbol(q, Decl(iteratorZipInputs.ts, 43, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const s: unique symbol; +>s : Symbol(s, Decl(iteratorZipInputs.ts, 46, 13)) + +declare const t: { a: Iterable; [s]?: Iterable; }; +>t : Symbol(t, Decl(iteratorZipInputs.ts, 47, 13)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 47, 18)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>[s] : Symbol([s], Decl(iteratorZipInputs.ts, 47, 39)) +>s : Symbol(s, Decl(iteratorZipInputs.ts, 46, 13)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + +const u: { a: number; [s]?: string; }[] = Iterator.zipKeyed(t).toArray(); +>u : Symbol(u, Decl(iteratorZipInputs.ts, 48, 5)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 48, 10)) +>[s] : Symbol([s], Decl(iteratorZipInputs.ts, 48, 21)) +>s : Symbol(s, Decl(iteratorZipInputs.ts, 46, 13)) +>Iterator.zipKeyed(t).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>t : Symbol(t, Decl(iteratorZipInputs.ts, 47, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +Iterator.zipKeyed({ a: [1], b: null }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 50, 19)) +>b : Symbol(b, Decl(iteratorZipInputs.ts, 50, 27)) + +Iterator.zipKeyed({ a: [1], b: false }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 51, 19)) +>b : Symbol(b, Decl(iteratorZipInputs.ts, 51, 27)) + +Iterator.zip([undefined]); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>undefined : Symbol(undefined) + +declare const v: { a?: undefined; }; +>v : Symbol(v, Decl(iteratorZipInputs.ts, 54, 13)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 54, 18)) + +const w: never[] = Iterator.zipKeyed(v).toArray(); +>w : Symbol(w, Decl(iteratorZipInputs.ts, 55, 5)) +>Iterator.zipKeyed(v).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>v : Symbol(v, Decl(iteratorZipInputs.ts, 54, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const x: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); +>x : Symbol(x, Decl(iteratorZipInputs.ts, 56, 5)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 56, 10)) +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 56, 47)) +>b : Symbol(b, Decl(iteratorZipInputs.ts, 56, 55)) +>undefined : Symbol(undefined) +>mode : Symbol(mode, Decl(iteratorZipInputs.ts, 56, 73)) +>padding : Symbol(padding, Decl(iteratorZipInputs.ts, 56, 90)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 56, 101)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const y: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); +>y : Symbol(y, Decl(iteratorZipInputs.ts, 57, 5)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 57, 10)) +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 57, 59)) +>b : Symbol(b, Decl(iteratorZipInputs.ts, 57, 67)) +>undefined : Symbol(undefined) +>mode : Symbol(mode, Decl(iteratorZipInputs.ts, 57, 85)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +function f1(a: Iterable) { +>f1 : Symbol(f1, Decl(iteratorZipInputs.ts, 57, 115)) +>T : Symbol(T, Decl(iteratorZipInputs.ts, 59, 12)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 59, 15)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>T : Symbol(T, Decl(iteratorZipInputs.ts, 59, 12)) + + const b: { a: T; }[] = Iterator.zipKeyed({ a }).toArray(); +>b : Symbol(b, Decl(iteratorZipInputs.ts, 60, 9)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 60, 14)) +>T : Symbol(T, Decl(iteratorZipInputs.ts, 59, 12)) +>Iterator.zipKeyed({ a }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 60, 46)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + + const c: [T][] = Iterator.zip([a]).toArray(); +>c : Symbol(c, Decl(iteratorZipInputs.ts, 61, 9)) +>T : Symbol(T, Decl(iteratorZipInputs.ts, 59, 12)) +>Iterator.zip([a]).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>a : Symbol(a, Decl(iteratorZipInputs.ts, 59, 15)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + + return { b, c }; +>b : Symbol(b, Decl(iteratorZipInputs.ts, 62, 12)) +>c : Symbol(c, Decl(iteratorZipInputs.ts, 62, 15)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=true).types b/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=true).types new file mode 100644 index 0000000000000..cfaab4fb9af24 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=true).types @@ -0,0 +1,511 @@ +//// [tests/cases/compiler/iteratorZipInputs.ts] //// + +=== iteratorZipInputs.ts === +Iterator.zip("ab"); +>Iterator.zip("ab") : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>"ab" : "ab" + +Iterator.zip(["ab"]); +>Iterator.zip(["ab"]) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>["ab"] : [string] +>"ab" : "ab" + +Iterator.zip(new Set(["ab"])); +>Iterator.zip(new Set(["ab"])) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>new Set(["ab"]) : Set +>Set : SetConstructor +>["ab"] : string[] +>"ab" : "ab" + +Iterator.zipKeyed("ab"); +>Iterator.zipKeyed("ab") : IteratorObject +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>"ab" : "ab" + +Iterator.zipKeyed({ a: "ab" }); +>Iterator.zipKeyed({ a: "ab" }) : IteratorObject<{ a: never; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>{ a: "ab" } : { a: string; } +>a : string +>"ab" : "ab" + +Iterator.zip([], { mode: "longest", padding: "ab" }); +>Iterator.zip([], { mode: "longest", padding: "ab" }) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[] : [] +>{ mode: "longest", padding: "ab" } : { mode: "longest"; padding: string; } +>mode : "longest" +>"longest" : "longest" +>padding : string +>"ab" : "ab" + +Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); +>Iterator.zip([["a"]], { mode: "longest", padding: "ab" }) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[["a"]] : [string[]] +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: "ab" } : { mode: "longest"; padding: string; } +>mode : "longest" +>"longest" : "longest" +>padding : string +>"ab" : "ab" + +Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); +>Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }) : IteratorObject +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>{} : {} +>{ mode: "longest", padding: "ab" } : { mode: "longest"; padding: string; } +>mode : "longest" +>"longest" : "longest" +>padding : string +>"ab" : "ab" + +const a: [string][] = Iterator.zip([new String("ab")]).toArray(); +>a : [string][] +>Iterator.zip([new String("ab")]).toArray() : [string][] +>Iterator.zip([new String("ab")]).toArray : () => [string][] +>Iterator.zip([new String("ab")]) : IteratorObject<[string], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[new String("ab")] : [String] +>new String("ab") : String +>String : StringConstructor +>"ab" : "ab" +>toArray : () => [string][] + +const b: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); +>b : { a: string; }[] +>a : string +>Iterator.zipKeyed({ a: new String("ab") }).toArray() : { a: string; }[] +>Iterator.zipKeyed({ a: new String("ab") }).toArray : () => { a: string; }[] +>Iterator.zipKeyed({ a: new String("ab") }) : IteratorObject<{ a: string; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>{ a: new String("ab") } : { a: String; } +>a : String +>new String("ab") : String +>String : StringConstructor +>"ab" : "ab" +>toArray : () => { a: string; }[] + +const c: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); +>c : (string | undefined)[][] +>Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray() : (string | undefined)[][] +>Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray : () => (string | undefined)[][] +>Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }) : IteratorObject<(string | undefined)[], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[["a"]] : string[][] +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: new String("ab") } : { mode: "longest"; padding: String; } +>mode : "longest" +>"longest" : "longest" +>padding : String +>new String("ab") : String +>String : StringConstructor +>"ab" : "ab" +>toArray : () => (string | undefined)[][] + +const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); +>d : { a: number; }[] +>Iterator.zipKeyed({ a: [1], b: undefined }).toArray() : { a: number; }[] +>Iterator.zipKeyed({ a: [1], b: undefined }).toArray : () => { a: number; }[] +>Iterator.zipKeyed({ a: [1], b: undefined }) : IteratorObject<{ a: number; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>{ a: [1], b: undefined } : { a: number[]; b: undefined; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : undefined +>undefined : undefined +>toArray : () => { a: number; }[] + +const e: { a: number; }[] = d; +>e : { a: number; }[] +>a : number +>d : { a: number; }[] + +d[0].b; +>d[0].b : any +>d[0] : { a: number; } +>d : { a: number; }[] +>0 : 0 +>b : any + +const f: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); +>f : never[] +>Iterator.zipKeyed({ a: undefined }).toArray() : never[] +>Iterator.zipKeyed({ a: undefined }).toArray : () => never[] +>Iterator.zipKeyed({ a: undefined }) : IteratorObject +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>{ a: undefined } : { a: undefined; } +>a : undefined +>undefined : undefined +>toArray : () => never[] + +const g: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); +>g : never[] +>Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray() : never[] +>Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray : () => never[] +>Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }) : IteratorObject +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>{ a: undefined } : { a: undefined; } +>a : undefined +>undefined : undefined +>{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } +>mode : "longest" +>"longest" : "longest" +>padding : {} +>{} : {} +>toArray : () => never[] + +interface I { + readonly a: Iterable; +>a : Iterable + + readonly b?: Iterator; +>b : Iterator | undefined + + readonly c: Iterable | undefined; +>c : Iterable | undefined + + readonly d?: undefined; +>d : undefined +} +declare const h: I; +>h : I + +const i = Iterator.zipKeyed(h).toArray(); +>i : { a: number; b?: string; c?: boolean; }[] +>Iterator.zipKeyed(h).toArray() : { a: number; b?: string; c?: boolean; }[] +>Iterator.zipKeyed(h).toArray : () => { a: number; b?: string; c?: boolean; }[] +>Iterator.zipKeyed(h) : IteratorObject<{ a: number; b?: string; c?: boolean; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>h : I +>toArray : () => { a: number; b?: string; c?: boolean; }[] + +const j: { a: number; b?: string; c?: boolean; }[] = i; +>j : { a: number; b?: string; c?: boolean; }[] +>a : number +>b : string | undefined +>c : boolean | undefined +>i : { a: number; b?: string; c?: boolean; }[] + +i[0].a = 2; +>i[0].a = 2 : 2 +>i[0].a : number +>i[0] : { a: number; b?: string; c?: boolean; } +>i : { a: number; b?: string; c?: boolean; }[] +>0 : 0 +>a : number +>2 : 2 + +i[0].b = "a"; +>i[0].b = "a" : "a" +>i[0].b : string +>i[0] : { a: number; b?: string; c?: boolean; } +>i : { a: number; b?: string; c?: boolean; }[] +>0 : 0 +>b : string +>"a" : "a" + +i[0].c = true; +>i[0].c = true : true +>i[0].c : boolean +>i[0] : { a: number; b?: string; c?: boolean; } +>i : { a: number; b?: string; c?: boolean; }[] +>0 : 0 +>c : boolean +>true : true + +i[0].d; +>i[0].d : any +>i[0] : { a: number; b?: string; c?: boolean; } +>i : { a: number; b?: string; c?: boolean; }[] +>0 : 0 +>d : any + +const k: { a: number; c: boolean; }[] = i; +>k : { a: number; c: boolean; }[] +>a : number +>c : boolean +>i : { a: number; b?: string; c?: boolean; }[] + +const l: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); +>l : { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] +>a : number | undefined +>b : string | undefined +>c : boolean | undefined +>Iterator.zipKeyed(h, { mode: "longest" }).toArray() : { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] +>Iterator.zipKeyed(h, { mode: "longest" }).toArray : () => { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] +>Iterator.zipKeyed(h, { mode: "longest" }) : IteratorObject<{ a: number | undefined; b?: string | undefined; c?: boolean | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>h : I +>{ mode: "longest" } : { mode: "longest"; } +>mode : "longest" +>"longest" : "longest" +>toArray : () => { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] + +declare const m: { a: Iterable; } | { b: Iterator; }; +>m : { a: Iterable; } | { b: Iterator; } +>a : Iterable +>b : Iterator + +const n: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(m).toArray(); +>n : ({ a: number; } | { b: string; })[] +>a : number +>b : string +>Iterator.zipKeyed(m).toArray() : ({ a: number; } | { b: string; })[] +>Iterator.zipKeyed(m).toArray : () => ({ a: number; } | { b: string; })[] +>Iterator.zipKeyed(m) : IteratorObject<{ a: number; } | { b: string; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>m : { a: Iterable; } | { b: Iterator; } +>toArray : () => ({ a: number; } | { b: string; })[] + +declare const o: { a: Iterable; } | { b: number; }; +>o : { a: Iterable; } | { b: number; } +>a : Iterable +>b : number + +Iterator.zipKeyed(o); +>Iterator.zipKeyed(o) : IteratorObject<{ a: number; } | { b: never; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>o : { a: Iterable; } | { b: number; } + +Iterator.zipKeyed(o, { mode: "longest" }); +>Iterator.zipKeyed(o, { mode: "longest" }) : IteratorObject<{ a: number; } | { b: never; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>o : { a: Iterable; } | { b: number; } +>{ mode: "longest" } : { mode: "longest"; } +>mode : "longest" +>"longest" : "longest" + +Iterator.zipKeyed(o, { mode: "longest", padding: {} }); +>Iterator.zipKeyed(o, { mode: "longest", padding: {} }) : IteratorObject<{ a: number; } | { b: never; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>o : { a: Iterable; } | { b: number; } +>{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } +>mode : "longest" +>"longest" : "longest" +>padding : {} +>{} : {} + +declare const p: { a?: Iterable; } | { b: string; }; +>p : { a?: Iterable; } | { b: string; } +>a : Iterable | undefined +>b : string + +Iterator.zipKeyed(p); +>Iterator.zipKeyed(p) : IteratorObject<{ a?: number; } | { b: never; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>p : { a?: Iterable; } | { b: string; } + +declare const q: { a: Iterable; } | { b: undefined; }; +>q : { a: Iterable; } | { b: undefined; } +>a : Iterable +>b : undefined + +const r: { a: number; }[] = Iterator.zipKeyed(q).toArray(); +>r : { a: number; }[] +>a : number +>Iterator.zipKeyed(q).toArray() : { a: number; }[] +>Iterator.zipKeyed(q).toArray : () => { a: number; }[] +>Iterator.zipKeyed(q) : IteratorObject<{ a: number; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>q : { a: Iterable; } | { b: undefined; } +>toArray : () => { a: number; }[] + +declare const s: unique symbol; +>s : unique symbol + +declare const t: { a: Iterable; [s]?: Iterable; }; +>t : { a: Iterable; [s]?: Iterable; } +>a : Iterable +>[s] : Iterable | undefined +>s : unique symbol + +const u: { a: number; [s]?: string; }[] = Iterator.zipKeyed(t).toArray(); +>u : { a: number; [s]?: string; }[] +>a : number +>[s] : string | undefined +>s : unique symbol +>Iterator.zipKeyed(t).toArray() : { a: number; [s]?: string; }[] +>Iterator.zipKeyed(t).toArray : () => { a: number; [s]?: string; }[] +>Iterator.zipKeyed(t) : IteratorObject<{ a: number; [s]?: string; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>t : { a: Iterable; [s]?: Iterable; } +>toArray : () => { a: number; [s]?: string; }[] + +Iterator.zipKeyed({ a: [1], b: null }); +>Iterator.zipKeyed({ a: [1], b: null }) : IteratorObject<{ a: number; b: never; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>{ a: [1], b: null } : { a: number[]; b: null; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : null + +Iterator.zipKeyed({ a: [1], b: false }); +>Iterator.zipKeyed({ a: [1], b: false }) : IteratorObject<{ a: number; b: never; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>{ a: [1], b: false } : { a: number[]; b: boolean; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : boolean +>false : false + +Iterator.zip([undefined]); +>Iterator.zip([undefined]) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[undefined] : [undefined] +>undefined : undefined + +declare const v: { a?: undefined; }; +>v : { a?: undefined; } +>a : undefined + +const w: never[] = Iterator.zipKeyed(v).toArray(); +>w : never[] +>Iterator.zipKeyed(v).toArray() : never[] +>Iterator.zipKeyed(v).toArray : () => never[] +>Iterator.zipKeyed(v) : IteratorObject +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>v : { a?: undefined; } +>toArray : () => never[] + +const x: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); +>x : { a: number; }[] +>a : number +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray() : { a: number; }[] +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray : () => { a: number; }[] +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }) : IteratorObject<{ a: number; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>{ a: [1], b: undefined } : { a: number[]; b: undefined; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : undefined +>undefined : undefined +>{ mode: "longest", padding: { a: 0 } } : { mode: "longest"; padding: { a: number; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: number; } +>{ a: 0 } : { a: number; } +>a : number +>0 : 0 +>toArray : () => { a: number; }[] + +const y: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); +>y : { a: number | undefined; }[] +>a : number | undefined +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray() : { a: number | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray : () => { a: number | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }) : IteratorObject<{ a: number | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>{ a: [1], b: undefined } : { a: number[]; b: undefined; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : undefined +>undefined : undefined +>{ mode: "longest" } : { mode: "longest"; } +>mode : "longest" +>"longest" : "longest" +>toArray : () => { a: number | undefined; }[] + +function f1(a: Iterable) { +>f1 : (a: Iterable) => { b: { a: T; }[]; c: [T][]; } +>a : Iterable + + const b: { a: T; }[] = Iterator.zipKeyed({ a }).toArray(); +>b : { a: T; }[] +>a : T +>Iterator.zipKeyed({ a }).toArray() : { a: T; }[] +>Iterator.zipKeyed({ a }).toArray : () => { a: T; }[] +>Iterator.zipKeyed({ a }) : IteratorObject<{ a: T; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K]; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K]; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K]; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K]; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K]; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K]; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>{ a } : { a: Iterable; } +>a : Iterable +>toArray : () => { a: T; }[] + + const c: [T][] = Iterator.zip([a]).toArray(); +>c : [T][] +>Iterator.zip([a]).toArray() : [T][] +>Iterator.zip([a]).toArray : () => [T][] +>Iterator.zip([a]) : IteratorObject<[T], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T_1, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T_1, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T_1, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T_1 extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T_1 extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T_1, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T_1, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T_1, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T_1 extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T_1 extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[a] : [Iterable] +>a : Iterable +>toArray : () => [T][] + + return { b, c }; +>{ b, c } : { b: { a: T; }[]; c: [T][]; } +>b : { a: T; }[] +>c : [T][] +} + diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=false).errors.txt b/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=false).errors.txt new file mode 100644 index 0000000000000..4ba9821668036 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=false).errors.txt @@ -0,0 +1,215 @@ +iteratorZipPadding.ts(4,7): error TS2322: Type '[number, ...(number | undefined)[]][]' is not assignable to type 'number[][]'. + Type '[number, ...(number | undefined)[]]' is not assignable to type 'number[]'. + Type 'number | undefined' is not assignable to type 'number'. + Type 'undefined' is not assignable to type 'number'. +iteratorZipPadding.ts(9,7): error TS2322: Type 'IteratorZipResult<{ [x: string]: Iterable; } & {}, undefined, {}>[]' is not assignable to type 'Record[]'. + Type 'IteratorZipResult<{ [x: string]: Iterable; } & {}, undefined, {}>' is not assignable to type 'Record'. + 'string' index signatures are incompatible. + Type 'number | undefined' is not assignable to type 'number'. + Type 'undefined' is not assignable to type 'number'. +iteratorZipPadding.ts(14,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record>[]' is not assignable to type '{ a: number; b: number; }[]'. + Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record>' is not assignable to type '{ a: number; b: number; }'. + Types of property 'a' are incompatible. + Type 'number | undefined' is not assignable to type 'number'. + Type 'undefined' is not assignable to type 'number'. +iteratorZipPadding.ts(23,7): error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. + Type '[number, string | undefined]' is not assignable to type '[number, string]'. + Type at position 1 in source is not compatible with type at position 1 in target. + Type 'string | undefined' is not assignable to type 'string'. + Type 'undefined' is not assignable to type 'string'. +iteratorZipPadding.ts(26,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; }>[]' is not assignable to type '{ a: number; b: string; }[]'. + Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; b: string; }'. + Types of property 'b' are incompatible. + Type 'string | undefined' is not assignable to type 'string'. + Type 'undefined' is not assignable to type 'string'. +iteratorZipPadding.ts(32,7): error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. + Type '[number, string | undefined]' is not assignable to type '[number, string]'. + Type at position 1 in source is not compatible with type at position 1 in target. + Type 'string | undefined' is not assignable to type 'string'. + Type 'undefined' is not assignable to type 'string'. +iteratorZipPadding.ts(36,7): error TS2322: Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>[]' is not assignable to type 'number[][]'. + Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>' is not assignable to type 'number[]'. + Type '[number, number | undefined]' is not assignable to type 'number[]'. + Type 'number | undefined' is not assignable to type 'number'. + Type 'undefined' is not assignable to type 'number'. +iteratorZipPadding.ts(39,7): error TS2322: Type '(IteratorZipResult<{ a: Iterable; } & {}, undefined, { a: number; }> | IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>)[]' is not assignable to type '({ a: number; } | { b: string; })[]'. + Type 'IteratorZipResult<{ a: Iterable; } & {}, undefined, { a: number; }> | IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; } | { b: string; }'. + Type 'IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; } | { b: string; }'. + Type 'IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ b: string; }'. + Types of property 'b' are incompatible. + Type 'string | undefined' is not assignable to type 'string'. + Type 'undefined' is not assignable to type 'string'. +iteratorZipPadding.ts(43,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; } | { b: string; }>[]' is not assignable to type '{ a: number; b: string; }[]'. + Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; } | { b: string; }>' is not assignable to type '{ a: number; b: string; }'. + Types of property 'a' are incompatible. + Type 'number | undefined' is not assignable to type 'number'. + Type 'undefined' is not assignable to type 'number'. +iteratorZipPadding.ts(46,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, { a: undefined; b: number; }>[]' is not assignable to type '{ a: number; b: number; }[]'. + Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, { a: undefined; b: number; }>' is not assignable to type '{ a: number; b: number; }'. + Types of property 'a' are incompatible. + Type 'number | undefined' is not assignable to type 'number'. + Type 'undefined' is not assignable to type 'number'. +iteratorZipPadding.ts(50,7): error TS2322: Type 'IteratorZipResult<{ [x: `a${string}`]: Iterable; } & {}, undefined, {}>[]' is not assignable to type '{ [x: `a${string}`]: number; }[]'. + Type 'IteratorZipResult<{ [x: `a${string}`]: Iterable; } & {}, undefined, {}>' is not assignable to type '{ [x: `a${string}`]: number; }'. + '`a${string}`' index signatures are incompatible. + Type 'number | undefined' is not assignable to type 'number'. + Type 'undefined' is not assignable to type 'number'. +iteratorZipPadding.ts(58,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record & { a: number; }>[]' is not assignable to type '{ a: number; b: number; }[]'. + Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record & { a: number; }>' is not assignable to type '{ a: number; b: number; }'. + Types of property 'b' are incompatible. + Type 'number | undefined' is not assignable to type 'number'. + Type 'undefined' is not assignable to type 'number'. +iteratorZipPadding.ts(63,7): error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. + Type '[number, string | undefined]' is not assignable to type '[number, string]'. + Type at position 1 in source is not compatible with type at position 1 in target. + Type 'string | undefined' is not assignable to type 'string'. + Type 'undefined' is not assignable to type 'string'. + + +==== iteratorZipPadding.ts (13 errors) ==== + const a: [Iterable, ...Iterable[]] = [[1, 2], [3]]; + const b = Iterator.zip(a, { mode: "longest", padding: [0] }).toArray(); + const c: (number | undefined)[][] = b; + const d: number[][] = b; + ~ +!!! error TS2322: Type '[number, ...(number | undefined)[]][]' is not assignable to type 'number[][]'. +!!! error TS2322: Type '[number, ...(number | undefined)[]]' is not assignable to type 'number[]'. +!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'undefined' is not assignable to type 'number'. + + const e: Record> = { a: [1], b: [2, 3] }; + const f = Iterator.zipKeyed(e, { mode: "longest", padding: {} }).toArray(); + const g: Record[] = f; + const h: Record[] = f; + ~ +!!! error TS2322: Type 'IteratorZipResult<{ [x: string]: Iterable; } & {}, undefined, {}>[]' is not assignable to type 'Record[]'. +!!! error TS2322: Type 'IteratorZipResult<{ [x: string]: Iterable; } & {}, undefined, {}>' is not assignable to type 'Record'. +!!! error TS2322: 'string' index signatures are incompatible. +!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'undefined' is not assignable to type 'number'. + + declare const i: Record; + const j = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: i }).toArray(); + const k: { a: number | undefined; b: number | undefined; }[] = j; + const l: { a: number; b: number; }[] = j; + ~ +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record>[]' is not assignable to type '{ a: number; b: number; }[]'. +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record>' is not assignable to type '{ a: number; b: number; }'. +!!! error TS2322: Types of property 'a' are incompatible. +!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'undefined' is not assignable to type 'number'. + + const m = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); + const n: [number, string][] = m; + const o = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); + const p: { a: number; b: string; }[] = o; + + const q = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); + const r: [number | undefined, string | undefined][] = q; + const s: [number, string][] = q; + ~ +!!! error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. +!!! error TS2322: Type '[number, string | undefined]' is not assignable to type '[number, string]'. +!!! error TS2322: Type at position 1 in source is not compatible with type at position 1 in target. +!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. +!!! error TS2322: Type 'undefined' is not assignable to type 'string'. + const t = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); + const u: { a: number | undefined; b: string | undefined; }[] = t; + const v: { a: number; b: string; }[] = t; + ~ +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; }>[]' is not assignable to type '{ a: number; b: string; }[]'. +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; b: string; }'. +!!! error TS2322: Types of property 'b' are incompatible. +!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. +!!! error TS2322: Type 'undefined' is not assignable to type 'string'. + + declare const w: readonly [number, string]; + const x: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: w }).toArray(); + declare const y: [number, string?]; + const z = Iterator.zip([[1], ["a"]], { mode: "longest", padding: y }).toArray(); + const a1: [number, string][] = z; + ~~ +!!! error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. +!!! error TS2322: Type '[number, string | undefined]' is not assignable to type '[number, string]'. +!!! error TS2322: Type at position 1 in source is not compatible with type at position 1 in target. +!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. +!!! error TS2322: Type 'undefined' is not assignable to type 'string'. + + declare const b1: [Iterable] | [Iterable, Iterable]; + const c1 = Iterator.zip(b1, { mode: "longest", padding: [0] }).toArray(); + const d1: number[][] = c1; + ~~ +!!! error TS2322: Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>[]' is not assignable to type 'number[][]'. +!!! error TS2322: Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>' is not assignable to type 'number[]'. +!!! error TS2322: Type '[number, number | undefined]' is not assignable to type 'number[]'. +!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'undefined' is not assignable to type 'number'. + declare const e1: { a: Iterable; } | { b: Iterable; }; + const f1 = Iterator.zipKeyed(e1, { mode: "longest", padding: { a: 0 } }).toArray(); + const g1: ({ a: number; } | { b: string; })[] = f1; + ~~ +!!! error TS2322: Type '(IteratorZipResult<{ a: Iterable; } & {}, undefined, { a: number; }> | IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>)[]' is not assignable to type '({ a: number; } | { b: string; })[]'. +!!! error TS2322: Type 'IteratorZipResult<{ a: Iterable; } & {}, undefined, { a: number; }> | IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; } | { b: string; }'. +!!! error TS2322: Type 'IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; } | { b: string; }'. +!!! error TS2322: Type 'IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ b: string; }'. +!!! error TS2322: Types of property 'b' are incompatible. +!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. +!!! error TS2322: Type 'undefined' is not assignable to type 'string'. + + declare const h1: { a: number; } | { b: string; }; + const i1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: h1 }).toArray(); + const j1: { a: number; b: string; }[] = i1; + ~~ +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; } | { b: string; }>[]' is not assignable to type '{ a: number; b: string; }[]'. +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; } | { b: string; }>' is not assignable to type '{ a: number; b: string; }'. +!!! error TS2322: Types of property 'a' are incompatible. +!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'undefined' is not assignable to type 'number'. + + const k1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); + const l1: { a: number; b: number; }[] = k1; + ~~ +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, { a: undefined; b: number; }>[]' is not assignable to type '{ a: number; b: number; }[]'. +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, { a: undefined; b: number; }>' is not assignable to type '{ a: number; b: number; }'. +!!! error TS2322: Types of property 'a' are incompatible. +!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'undefined' is not assignable to type 'number'. + + declare const m1: { [K in `a${string}`]: Iterable; }; + const n1 = Iterator.zipKeyed(m1, { mode: "longest", padding: {} }).toArray(); + const o1: { [K in `a${string}`]: number; }[] = n1; + ~~ +!!! error TS2322: Type 'IteratorZipResult<{ [x: `a${string}`]: Iterable; } & {}, undefined, {}>[]' is not assignable to type '{ [x: `a${string}`]: number; }[]'. +!!! error TS2322: Type 'IteratorZipResult<{ [x: `a${string}`]: Iterable; } & {}, undefined, {}>' is not assignable to type '{ [x: `a${string}`]: number; }'. +!!! error TS2322: '`a${string}`' index signatures are incompatible. +!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'undefined' is not assignable to type 'number'. + + declare const p1: unique symbol; + const q1: { [p1]: number; }[] = Iterator.zipKeyed({ [p1]: [1] }, { mode: "longest", padding: { [p1]: 0 } }).toArray(); + + declare const r1: Record & { a: number; }; + const s1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: r1 }).toArray(); + const t1: { a: number; b: number | undefined; }[] = s1; + const u1: { a: number; b: number; }[] = s1; + ~~ +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record & { a: number; }>[]' is not assignable to type '{ a: number; b: number; }[]'. +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record & { a: number; }>' is not assignable to type '{ a: number; b: number; }'. +!!! error TS2322: Types of property 'b' are incompatible. +!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'undefined' is not assignable to type 'number'. + + declare const v1: [number] | [number, string]; + const w1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: v1 }).toArray(); + const x1: [number, string | undefined][] = w1; + const y1: [number, string][] = w1; + ~~ +!!! error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. +!!! error TS2322: Type '[number, string | undefined]' is not assignable to type '[number, string]'. +!!! error TS2322: Type at position 1 in source is not compatible with type at position 1 in target. +!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. +!!! error TS2322: Type 'undefined' is not assignable to type 'string'. + + const z1: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); + const a2: { a: number | undefined; b: number; }[] = k1; + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=false).js b/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=false).js new file mode 100644 index 0000000000000..408ebf1bc1fac --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=false).js @@ -0,0 +1,248 @@ +//// [tests/cases/compiler/iteratorZipPadding.ts] //// + +//// [iteratorZipPadding.ts] +const a: [Iterable, ...Iterable[]] = [[1, 2], [3]]; +const b = Iterator.zip(a, { mode: "longest", padding: [0] }).toArray(); +const c: (number | undefined)[][] = b; +const d: number[][] = b; + +const e: Record> = { a: [1], b: [2, 3] }; +const f = Iterator.zipKeyed(e, { mode: "longest", padding: {} }).toArray(); +const g: Record[] = f; +const h: Record[] = f; + +declare const i: Record; +const j = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: i }).toArray(); +const k: { a: number | undefined; b: number | undefined; }[] = j; +const l: { a: number; b: number; }[] = j; + +const m = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); +const n: [number, string][] = m; +const o = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); +const p: { a: number; b: string; }[] = o; + +const q = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); +const r: [number | undefined, string | undefined][] = q; +const s: [number, string][] = q; +const t = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); +const u: { a: number | undefined; b: string | undefined; }[] = t; +const v: { a: number; b: string; }[] = t; + +declare const w: readonly [number, string]; +const x: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: w }).toArray(); +declare const y: [number, string?]; +const z = Iterator.zip([[1], ["a"]], { mode: "longest", padding: y }).toArray(); +const a1: [number, string][] = z; + +declare const b1: [Iterable] | [Iterable, Iterable]; +const c1 = Iterator.zip(b1, { mode: "longest", padding: [0] }).toArray(); +const d1: number[][] = c1; +declare const e1: { a: Iterable; } | { b: Iterable; }; +const f1 = Iterator.zipKeyed(e1, { mode: "longest", padding: { a: 0 } }).toArray(); +const g1: ({ a: number; } | { b: string; })[] = f1; + +declare const h1: { a: number; } | { b: string; }; +const i1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: h1 }).toArray(); +const j1: { a: number; b: string; }[] = i1; + +const k1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); +const l1: { a: number; b: number; }[] = k1; + +declare const m1: { [K in `a${string}`]: Iterable; }; +const n1 = Iterator.zipKeyed(m1, { mode: "longest", padding: {} }).toArray(); +const o1: { [K in `a${string}`]: number; }[] = n1; + +declare const p1: unique symbol; +const q1: { [p1]: number; }[] = Iterator.zipKeyed({ [p1]: [1] }, { mode: "longest", padding: { [p1]: 0 } }).toArray(); + +declare const r1: Record & { a: number; }; +const s1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: r1 }).toArray(); +const t1: { a: number; b: number | undefined; }[] = s1; +const u1: { a: number; b: number; }[] = s1; + +declare const v1: [number] | [number, string]; +const w1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: v1 }).toArray(); +const x1: [number, string | undefined][] = w1; +const y1: [number, string][] = w1; + +const z1: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); +const a2: { a: number | undefined; b: number; }[] = k1; + + +//// [iteratorZipPadding.js] +"use strict"; +const a = [[1, 2], [3]]; +const b = Iterator.zip(a, { mode: "longest", padding: [0] }).toArray(); +const c = b; +const d = b; +const e = { a: [1], b: [2, 3] }; +const f = Iterator.zipKeyed(e, { mode: "longest", padding: {} }).toArray(); +const g = f; +const h = f; +const j = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: i }).toArray(); +const k = j; +const l = j; +const m = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); +const n = m; +const o = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); +const p = o; +const q = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); +const r = q; +const s = q; +const t = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); +const u = t; +const v = t; +const x = Iterator.zip([[1], ["a"]], { mode: "longest", padding: w }).toArray(); +const z = Iterator.zip([[1], ["a"]], { mode: "longest", padding: y }).toArray(); +const a1 = z; +const c1 = Iterator.zip(b1, { mode: "longest", padding: [0] }).toArray(); +const d1 = c1; +const f1 = Iterator.zipKeyed(e1, { mode: "longest", padding: { a: 0 } }).toArray(); +const g1 = f1; +const i1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: h1 }).toArray(); +const j1 = i1; +const k1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); +const l1 = k1; +const n1 = Iterator.zipKeyed(m1, { mode: "longest", padding: {} }).toArray(); +const o1 = n1; +const q1 = Iterator.zipKeyed({ [p1]: [1] }, { mode: "longest", padding: { [p1]: 0 } }).toArray(); +const s1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: r1 }).toArray(); +const t1 = s1; +const u1 = s1; +const w1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: v1 }).toArray(); +const x1 = w1; +const y1 = w1; +const z1 = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); +const a2 = k1; + + +//// [iteratorZipPadding.d.ts] +declare const a: [Iterable, ...Iterable[]]; +declare const b: [number, ...(number | undefined)[]][]; +declare const c: (number | undefined)[][]; +declare const d: number[][]; +declare const e: Record>; +declare const f: { + [x: string]: number | undefined; +}[]; +declare const g: Record[]; +declare const h: Record[]; +declare const i: Record; +declare const j: { + a: number | undefined; + b: number | undefined; +}[]; +declare const k: { + a: number | undefined; + b: number | undefined; +}[]; +declare const l: { + a: number; + b: number; +}[]; +declare const m: [number, string][]; +declare const n: [number, string][]; +declare const o: { + a: number; + b: string; +}[]; +declare const p: { + a: number; + b: string; +}[]; +declare const q: [number, string | undefined][]; +declare const r: [number | undefined, string | undefined][]; +declare const s: [number, string][]; +declare const t: { + a: number; + b: string | undefined; +}[]; +declare const u: { + a: number | undefined; + b: string | undefined; +}[]; +declare const v: { + a: number; + b: string; +}[]; +declare const w: readonly [number, string]; +declare const x: [number, string][]; +declare const y: [number, string?]; +declare const z: [number, string | undefined][]; +declare const a1: [number, string][]; +declare const b1: [Iterable] | [Iterable, Iterable]; +declare const c1: ([number] | [number, number | undefined])[]; +declare const d1: number[][]; +declare const e1: { + a: Iterable; +} | { + b: Iterable; +}; +declare const f1: ({ + a: number; +} | { + b: string | undefined; +})[]; +declare const g1: ({ + a: number; +} | { + b: string; +})[]; +declare const h1: { + a: number; +} | { + b: string; +}; +declare const i1: { + a: number | undefined; + b: string | undefined; +}[]; +declare const j1: { + a: number; + b: string; +}[]; +declare const k1: { + a: number | undefined; + b: number; +}[]; +declare const l1: { + a: number; + b: number; +}[]; +declare const m1: { + [K in `a${string}`]: Iterable; +}; +declare const n1: { + [x: `a${string}`]: number | undefined; +}[]; +declare const o1: { + [K in `a${string}`]: number; +}[]; +declare const p1: unique symbol; +declare const q1: { + [p1]: number; +}[]; +declare const r1: Record & { + a: number; +}; +declare const s1: { + a: number; + b: number | undefined; +}[]; +declare const t1: { + a: number; + b: number | undefined; +}[]; +declare const u1: { + a: number; + b: number; +}[]; +declare const v1: [number] | [number, string]; +declare const w1: [number, string | undefined][]; +declare const x1: [number, string | undefined][]; +declare const y1: [number, string][]; +declare const z1: [number | undefined, number][]; +declare const a2: { + a: number | undefined; + b: number; +}[]; diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=false).symbols b/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=false).symbols new file mode 100644 index 0000000000000..7284c5da3fbf8 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=false).symbols @@ -0,0 +1,393 @@ +//// [tests/cases/compiler/iteratorZipPadding.ts] //// + +=== iteratorZipPadding.ts === +const a: [Iterable, ...Iterable[]] = [[1, 2], [3]]; +>a : Symbol(a, Decl(iteratorZipPadding.ts, 0, 5)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + +const b = Iterator.zip(a, { mode: "longest", padding: [0] }).toArray(); +>b : Symbol(b, Decl(iteratorZipPadding.ts, 1, 5)) +>Iterator.zip(a, { mode: "longest", padding: [0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 0, 5)) +>mode : Symbol(mode, Decl(iteratorZipPadding.ts, 1, 27)) +>padding : Symbol(padding, Decl(iteratorZipPadding.ts, 1, 44)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const c: (number | undefined)[][] = b; +>c : Symbol(c, Decl(iteratorZipPadding.ts, 2, 5)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 1, 5)) + +const d: number[][] = b; +>d : Symbol(d, Decl(iteratorZipPadding.ts, 3, 5)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 1, 5)) + +const e: Record> = { a: [1], b: [2, 3] }; +>e : Symbol(e, Decl(iteratorZipPadding.ts, 5, 5)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 5, 45)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 5, 53)) + +const f = Iterator.zipKeyed(e, { mode: "longest", padding: {} }).toArray(); +>f : Symbol(f, Decl(iteratorZipPadding.ts, 6, 5)) +>Iterator.zipKeyed(e, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>e : Symbol(e, Decl(iteratorZipPadding.ts, 5, 5)) +>mode : Symbol(mode, Decl(iteratorZipPadding.ts, 6, 32)) +>padding : Symbol(padding, Decl(iteratorZipPadding.ts, 6, 49)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const g: Record[] = f; +>g : Symbol(g, Decl(iteratorZipPadding.ts, 7, 5)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>f : Symbol(f, Decl(iteratorZipPadding.ts, 6, 5)) + +const h: Record[] = f; +>h : Symbol(h, Decl(iteratorZipPadding.ts, 8, 5)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>f : Symbol(f, Decl(iteratorZipPadding.ts, 6, 5)) + +declare const i: Record; +>i : Symbol(i, Decl(iteratorZipPadding.ts, 10, 13)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) + +const j = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: i }).toArray(); +>j : Symbol(j, Decl(iteratorZipPadding.ts, 11, 5)) +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: i }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 11, 29)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 11, 37)) +>mode : Symbol(mode, Decl(iteratorZipPadding.ts, 11, 52)) +>padding : Symbol(padding, Decl(iteratorZipPadding.ts, 11, 69)) +>i : Symbol(i, Decl(iteratorZipPadding.ts, 10, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const k: { a: number | undefined; b: number | undefined; }[] = j; +>k : Symbol(k, Decl(iteratorZipPadding.ts, 12, 5)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 12, 10)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 12, 33)) +>j : Symbol(j, Decl(iteratorZipPadding.ts, 11, 5)) + +const l: { a: number; b: number; }[] = j; +>l : Symbol(l, Decl(iteratorZipPadding.ts, 13, 5)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 13, 10)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 13, 21)) +>j : Symbol(j, Decl(iteratorZipPadding.ts, 11, 5)) + +const m = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); +>m : Symbol(m, Decl(iteratorZipPadding.ts, 15, 5)) +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZipPadding.ts, 15, 38)) +>padding : Symbol(padding, Decl(iteratorZipPadding.ts, 15, 55)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const n: [number, string][] = m; +>n : Symbol(n, Decl(iteratorZipPadding.ts, 16, 5)) +>m : Symbol(m, Decl(iteratorZipPadding.ts, 15, 5)) + +const o = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); +>o : Symbol(o, Decl(iteratorZipPadding.ts, 17, 5)) +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 17, 29)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 17, 37)) +>mode : Symbol(mode, Decl(iteratorZipPadding.ts, 17, 51)) +>padding : Symbol(padding, Decl(iteratorZipPadding.ts, 17, 68)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 17, 79)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 17, 85)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const p: { a: number; b: string; }[] = o; +>p : Symbol(p, Decl(iteratorZipPadding.ts, 18, 5)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 18, 10)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 18, 21)) +>o : Symbol(o, Decl(iteratorZipPadding.ts, 17, 5)) + +const q = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); +>q : Symbol(q, Decl(iteratorZipPadding.ts, 20, 5)) +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZipPadding.ts, 20, 38)) +>padding : Symbol(padding, Decl(iteratorZipPadding.ts, 20, 55)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const r: [number | undefined, string | undefined][] = q; +>r : Symbol(r, Decl(iteratorZipPadding.ts, 21, 5)) +>q : Symbol(q, Decl(iteratorZipPadding.ts, 20, 5)) + +const s: [number, string][] = q; +>s : Symbol(s, Decl(iteratorZipPadding.ts, 22, 5)) +>q : Symbol(q, Decl(iteratorZipPadding.ts, 20, 5)) + +const t = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); +>t : Symbol(t, Decl(iteratorZipPadding.ts, 23, 5)) +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 23, 29)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 23, 37)) +>mode : Symbol(mode, Decl(iteratorZipPadding.ts, 23, 51)) +>padding : Symbol(padding, Decl(iteratorZipPadding.ts, 23, 68)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 23, 79)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const u: { a: number | undefined; b: string | undefined; }[] = t; +>u : Symbol(u, Decl(iteratorZipPadding.ts, 24, 5)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 24, 10)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 24, 33)) +>t : Symbol(t, Decl(iteratorZipPadding.ts, 23, 5)) + +const v: { a: number; b: string; }[] = t; +>v : Symbol(v, Decl(iteratorZipPadding.ts, 25, 5)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 25, 10)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 25, 21)) +>t : Symbol(t, Decl(iteratorZipPadding.ts, 23, 5)) + +declare const w: readonly [number, string]; +>w : Symbol(w, Decl(iteratorZipPadding.ts, 27, 13)) + +const x: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: w }).toArray(); +>x : Symbol(x, Decl(iteratorZipPadding.ts, 28, 5)) +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: w }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZipPadding.ts, 28, 58)) +>padding : Symbol(padding, Decl(iteratorZipPadding.ts, 28, 75)) +>w : Symbol(w, Decl(iteratorZipPadding.ts, 27, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const y: [number, string?]; +>y : Symbol(y, Decl(iteratorZipPadding.ts, 29, 13)) + +const z = Iterator.zip([[1], ["a"]], { mode: "longest", padding: y }).toArray(); +>z : Symbol(z, Decl(iteratorZipPadding.ts, 30, 5)) +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: y }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZipPadding.ts, 30, 38)) +>padding : Symbol(padding, Decl(iteratorZipPadding.ts, 30, 55)) +>y : Symbol(y, Decl(iteratorZipPadding.ts, 29, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a1: [number, string][] = z; +>a1 : Symbol(a1, Decl(iteratorZipPadding.ts, 31, 5)) +>z : Symbol(z, Decl(iteratorZipPadding.ts, 30, 5)) + +declare const b1: [Iterable] | [Iterable, Iterable]; +>b1 : Symbol(b1, Decl(iteratorZipPadding.ts, 33, 13)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + +const c1 = Iterator.zip(b1, { mode: "longest", padding: [0] }).toArray(); +>c1 : Symbol(c1, Decl(iteratorZipPadding.ts, 34, 5)) +>Iterator.zip(b1, { mode: "longest", padding: [0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>b1 : Symbol(b1, Decl(iteratorZipPadding.ts, 33, 13)) +>mode : Symbol(mode, Decl(iteratorZipPadding.ts, 34, 29)) +>padding : Symbol(padding, Decl(iteratorZipPadding.ts, 34, 46)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const d1: number[][] = c1; +>d1 : Symbol(d1, Decl(iteratorZipPadding.ts, 35, 5)) +>c1 : Symbol(c1, Decl(iteratorZipPadding.ts, 34, 5)) + +declare const e1: { a: Iterable; } | { b: Iterable; }; +>e1 : Symbol(e1, Decl(iteratorZipPadding.ts, 36, 13)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 36, 19)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 36, 46)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + +const f1 = Iterator.zipKeyed(e1, { mode: "longest", padding: { a: 0 } }).toArray(); +>f1 : Symbol(f1, Decl(iteratorZipPadding.ts, 37, 5)) +>Iterator.zipKeyed(e1, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>e1 : Symbol(e1, Decl(iteratorZipPadding.ts, 36, 13)) +>mode : Symbol(mode, Decl(iteratorZipPadding.ts, 37, 34)) +>padding : Symbol(padding, Decl(iteratorZipPadding.ts, 37, 51)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 37, 62)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const g1: ({ a: number; } | { b: string; })[] = f1; +>g1 : Symbol(g1, Decl(iteratorZipPadding.ts, 38, 5)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 38, 12)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 38, 29)) +>f1 : Symbol(f1, Decl(iteratorZipPadding.ts, 37, 5)) + +declare const h1: { a: number; } | { b: string; }; +>h1 : Symbol(h1, Decl(iteratorZipPadding.ts, 40, 13)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 40, 19)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 40, 36)) + +const i1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: h1 }).toArray(); +>i1 : Symbol(i1, Decl(iteratorZipPadding.ts, 41, 5)) +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: h1 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 41, 30)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 41, 38)) +>mode : Symbol(mode, Decl(iteratorZipPadding.ts, 41, 52)) +>padding : Symbol(padding, Decl(iteratorZipPadding.ts, 41, 69)) +>h1 : Symbol(h1, Decl(iteratorZipPadding.ts, 40, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const j1: { a: number; b: string; }[] = i1; +>j1 : Symbol(j1, Decl(iteratorZipPadding.ts, 42, 5)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 42, 11)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 42, 22)) +>i1 : Symbol(i1, Decl(iteratorZipPadding.ts, 41, 5)) + +const k1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); +>k1 : Symbol(k1, Decl(iteratorZipPadding.ts, 44, 5)) +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 44, 30)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 44, 38)) +>mode : Symbol(mode, Decl(iteratorZipPadding.ts, 44, 50)) +>padding : Symbol(padding, Decl(iteratorZipPadding.ts, 44, 67)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 44, 78)) +>undefined : Symbol(undefined) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 44, 92)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const l1: { a: number; b: number; }[] = k1; +>l1 : Symbol(l1, Decl(iteratorZipPadding.ts, 45, 5)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 45, 11)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 45, 22)) +>k1 : Symbol(k1, Decl(iteratorZipPadding.ts, 44, 5)) + +declare const m1: { [K in `a${string}`]: Iterable; }; +>m1 : Symbol(m1, Decl(iteratorZipPadding.ts, 47, 13)) +>K : Symbol(K, Decl(iteratorZipPadding.ts, 47, 21)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + +const n1 = Iterator.zipKeyed(m1, { mode: "longest", padding: {} }).toArray(); +>n1 : Symbol(n1, Decl(iteratorZipPadding.ts, 48, 5)) +>Iterator.zipKeyed(m1, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>m1 : Symbol(m1, Decl(iteratorZipPadding.ts, 47, 13)) +>mode : Symbol(mode, Decl(iteratorZipPadding.ts, 48, 34)) +>padding : Symbol(padding, Decl(iteratorZipPadding.ts, 48, 51)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const o1: { [K in `a${string}`]: number; }[] = n1; +>o1 : Symbol(o1, Decl(iteratorZipPadding.ts, 49, 5)) +>K : Symbol(K, Decl(iteratorZipPadding.ts, 49, 13)) +>n1 : Symbol(n1, Decl(iteratorZipPadding.ts, 48, 5)) + +declare const p1: unique symbol; +>p1 : Symbol(p1, Decl(iteratorZipPadding.ts, 51, 13)) + +const q1: { [p1]: number; }[] = Iterator.zipKeyed({ [p1]: [1] }, { mode: "longest", padding: { [p1]: 0 } }).toArray(); +>q1 : Symbol(q1, Decl(iteratorZipPadding.ts, 52, 5)) +>[p1] : Symbol([p1], Decl(iteratorZipPadding.ts, 52, 11)) +>p1 : Symbol(p1, Decl(iteratorZipPadding.ts, 51, 13)) +>Iterator.zipKeyed({ [p1]: [1] }, { mode: "longest", padding: { [p1]: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>[p1] : Symbol([p1], Decl(iteratorZipPadding.ts, 52, 51)) +>p1 : Symbol(p1, Decl(iteratorZipPadding.ts, 51, 13)) +>mode : Symbol(mode, Decl(iteratorZipPadding.ts, 52, 66)) +>padding : Symbol(padding, Decl(iteratorZipPadding.ts, 52, 83)) +>[p1] : Symbol([p1], Decl(iteratorZipPadding.ts, 52, 94)) +>p1 : Symbol(p1, Decl(iteratorZipPadding.ts, 51, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const r1: Record & { a: number; }; +>r1 : Symbol(r1, Decl(iteratorZipPadding.ts, 54, 13)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 54, 44)) + +const s1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: r1 }).toArray(); +>s1 : Symbol(s1, Decl(iteratorZipPadding.ts, 55, 5)) +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: r1 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 55, 30)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 55, 38)) +>mode : Symbol(mode, Decl(iteratorZipPadding.ts, 55, 50)) +>padding : Symbol(padding, Decl(iteratorZipPadding.ts, 55, 67)) +>r1 : Symbol(r1, Decl(iteratorZipPadding.ts, 54, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const t1: { a: number; b: number | undefined; }[] = s1; +>t1 : Symbol(t1, Decl(iteratorZipPadding.ts, 56, 5)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 56, 11)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 56, 22)) +>s1 : Symbol(s1, Decl(iteratorZipPadding.ts, 55, 5)) + +const u1: { a: number; b: number; }[] = s1; +>u1 : Symbol(u1, Decl(iteratorZipPadding.ts, 57, 5)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 57, 11)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 57, 22)) +>s1 : Symbol(s1, Decl(iteratorZipPadding.ts, 55, 5)) + +declare const v1: [number] | [number, string]; +>v1 : Symbol(v1, Decl(iteratorZipPadding.ts, 59, 13)) + +const w1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: v1 }).toArray(); +>w1 : Symbol(w1, Decl(iteratorZipPadding.ts, 60, 5)) +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: v1 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZipPadding.ts, 60, 39)) +>padding : Symbol(padding, Decl(iteratorZipPadding.ts, 60, 56)) +>v1 : Symbol(v1, Decl(iteratorZipPadding.ts, 59, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const x1: [number, string | undefined][] = w1; +>x1 : Symbol(x1, Decl(iteratorZipPadding.ts, 61, 5)) +>w1 : Symbol(w1, Decl(iteratorZipPadding.ts, 60, 5)) + +const y1: [number, string][] = w1; +>y1 : Symbol(y1, Decl(iteratorZipPadding.ts, 62, 5)) +>w1 : Symbol(w1, Decl(iteratorZipPadding.ts, 60, 5)) + +const z1: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); +>z1 : Symbol(z1, Decl(iteratorZipPadding.ts, 64, 5)) +>Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZipPadding.ts, 64, 69)) +>padding : Symbol(padding, Decl(iteratorZipPadding.ts, 64, 86)) +>undefined : Symbol(undefined) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a2: { a: number | undefined; b: number; }[] = k1; +>a2 : Symbol(a2, Decl(iteratorZipPadding.ts, 65, 5)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 65, 11)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 65, 34)) +>k1 : Symbol(k1, Decl(iteratorZipPadding.ts, 44, 5)) + diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=false).types b/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=false).types new file mode 100644 index 0000000000000..b67a86444b7f1 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=false).types @@ -0,0 +1,549 @@ +//// [tests/cases/compiler/iteratorZipPadding.ts] //// + +=== iteratorZipPadding.ts === +const a: [Iterable, ...Iterable[]] = [[1, 2], [3]]; +>a : [Iterable, ...Iterable[]] +>[[1, 2], [3]] : [number[], number[]] +>[1, 2] : number[] +>1 : 1 +>2 : 2 +>[3] : number[] +>3 : 3 + +const b = Iterator.zip(a, { mode: "longest", padding: [0] }).toArray(); +>b : [number, ...(number | undefined)[]][] +>Iterator.zip(a, { mode: "longest", padding: [0] }).toArray() : [number, ...(number | undefined)[]][] +>Iterator.zip(a, { mode: "longest", padding: [0] }).toArray : () => [number, ...(number | undefined)[]][] +>Iterator.zip(a, { mode: "longest", padding: [0] }) : IteratorObject<[number, ...(number | undefined)[]], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>a : [Iterable, ...Iterable[]] +>{ mode: "longest", padding: [0] } : { mode: "longest"; padding: [number]; } +>mode : "longest" +>"longest" : "longest" +>padding : [number] +>[0] : [number] +>0 : 0 +>toArray : () => [number, ...(number | undefined)[]][] + +const c: (number | undefined)[][] = b; +>c : (number | undefined)[][] +>b : [number, ...(number | undefined)[]][] + +const d: number[][] = b; +>d : number[][] +>b : [number, ...(number | undefined)[]][] + +const e: Record> = { a: [1], b: [2, 3] }; +>e : Record> +>{ a: [1], b: [2, 3] } : { a: number[]; b: number[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : number[] +>[2, 3] : number[] +>2 : 2 +>3 : 3 + +const f = Iterator.zipKeyed(e, { mode: "longest", padding: {} }).toArray(); +>f : { [x: string]: number | undefined; }[] +>Iterator.zipKeyed(e, { mode: "longest", padding: {} }).toArray() : { [x: string]: number | undefined; }[] +>Iterator.zipKeyed(e, { mode: "longest", padding: {} }).toArray : () => { [x: string]: number | undefined; }[] +>Iterator.zipKeyed(e, { mode: "longest", padding: {} }) : IteratorObject<{ [x: string]: number | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>e : Record> +>{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } +>mode : "longest" +>"longest" : "longest" +>padding : {} +>{} : {} +>toArray : () => { [x: string]: number | undefined; }[] + +const g: Record[] = f; +>g : Record[] +>f : { [x: string]: number | undefined; }[] + +const h: Record[] = f; +>h : Record[] +>f : { [x: string]: number | undefined; }[] + +declare const i: Record; +>i : Record + +const j = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: i }).toArray(); +>j : { a: number | undefined; b: number | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: i }).toArray() : { a: number | undefined; b: number | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: i }).toArray : () => { a: number | undefined; b: number | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: i }) : IteratorObject<{ a: number | undefined; b: number | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>{ a: [1], b: [2, 3] } : { a: number[]; b: number[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : number[] +>[2, 3] : number[] +>2 : 2 +>3 : 3 +>{ mode: "longest", padding: i } : { mode: "longest"; padding: Record; } +>mode : "longest" +>"longest" : "longest" +>padding : Record +>i : Record +>toArray : () => { a: number | undefined; b: number | undefined; }[] + +const k: { a: number | undefined; b: number | undefined; }[] = j; +>k : { a: number | undefined; b: number | undefined; }[] +>a : number | undefined +>b : number | undefined +>j : { a: number | undefined; b: number | undefined; }[] + +const l: { a: number; b: number; }[] = j; +>l : { a: number; b: number; }[] +>a : number +>b : number +>j : { a: number | undefined; b: number | undefined; }[] + +const m = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); +>m : [number, string][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray() : [number, string][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray : () => [number, string][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }) : IteratorObject<[number, string], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] : [number[], string[]] +>[1] : number[] +>1 : 1 +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: [0, ""] } : { mode: "longest"; padding: [number, string]; } +>mode : "longest" +>"longest" : "longest" +>padding : [number, string] +>[0, ""] : [number, string] +>0 : 0 +>"" : "" +>toArray : () => [number, string][] + +const n: [number, string][] = m; +>n : [number, string][] +>m : [number, string][] + +const o = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); +>o : { a: number; b: string; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray() : { a: number; b: string; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray : () => { a: number; b: string; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }) : IteratorObject<{ a: number; b: string; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : string[] +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: { a: 0, b: "" } } : { mode: "longest"; padding: { a: number; b: string; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: number; b: string; } +>{ a: 0, b: "" } : { a: number; b: string; } +>a : number +>0 : 0 +>b : string +>"" : "" +>toArray : () => { a: number; b: string; }[] + +const p: { a: number; b: string; }[] = o; +>p : { a: number; b: string; }[] +>a : number +>b : string +>o : { a: number; b: string; }[] + +const q = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); +>q : [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray() : [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray : () => [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }) : IteratorObject<[number, string | undefined], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] : [number[], string[]] +>[1] : number[] +>1 : 1 +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: [0] } : { mode: "longest"; padding: [number]; } +>mode : "longest" +>"longest" : "longest" +>padding : [number] +>[0] : [number] +>0 : 0 +>toArray : () => [number, string | undefined][] + +const r: [number | undefined, string | undefined][] = q; +>r : [number | undefined, string | undefined][] +>q : [number, string | undefined][] + +const s: [number, string][] = q; +>s : [number, string][] +>q : [number, string | undefined][] + +const t = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); +>t : { a: number; b: string | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray() : { a: number; b: string | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray : () => { a: number; b: string | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }) : IteratorObject<{ a: number; b: string | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : string[] +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: { a: 0 } } : { mode: "longest"; padding: { a: number; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: number; } +>{ a: 0 } : { a: number; } +>a : number +>0 : 0 +>toArray : () => { a: number; b: string | undefined; }[] + +const u: { a: number | undefined; b: string | undefined; }[] = t; +>u : { a: number | undefined; b: string | undefined; }[] +>a : number | undefined +>b : string | undefined +>t : { a: number; b: string | undefined; }[] + +const v: { a: number; b: string; }[] = t; +>v : { a: number; b: string; }[] +>a : number +>b : string +>t : { a: number; b: string | undefined; }[] + +declare const w: readonly [number, string]; +>w : readonly [number, string] + +const x: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: w }).toArray(); +>x : [number, string][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: w }).toArray() : [number, string][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: w }).toArray : () => [number, string][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: w }) : IteratorObject<[number, string], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] : [number[], string[]] +>[1] : number[] +>1 : 1 +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: w } : { mode: "longest"; padding: readonly [number, string]; } +>mode : "longest" +>"longest" : "longest" +>padding : readonly [number, string] +>w : readonly [number, string] +>toArray : () => [number, string][] + +declare const y: [number, string?]; +>y : [number, (string | undefined)?] + +const z = Iterator.zip([[1], ["a"]], { mode: "longest", padding: y }).toArray(); +>z : [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: y }).toArray() : [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: y }).toArray : () => [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: y }) : IteratorObject<[number, string | undefined], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] : [number[], string[]] +>[1] : number[] +>1 : 1 +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: y } : { mode: "longest"; padding: [number, (string | undefined)?]; } +>mode : "longest" +>"longest" : "longest" +>padding : [number, (string | undefined)?] +>y : [number, (string | undefined)?] +>toArray : () => [number, string | undefined][] + +const a1: [number, string][] = z; +>a1 : [number, string][] +>z : [number, string | undefined][] + +declare const b1: [Iterable] | [Iterable, Iterable]; +>b1 : [Iterable] | [Iterable, Iterable] + +const c1 = Iterator.zip(b1, { mode: "longest", padding: [0] }).toArray(); +>c1 : ([number] | [number, number | undefined])[] +>Iterator.zip(b1, { mode: "longest", padding: [0] }).toArray() : ([number] | [number, number | undefined])[] +>Iterator.zip(b1, { mode: "longest", padding: [0] }).toArray : () => ([number] | [number, number | undefined])[] +>Iterator.zip(b1, { mode: "longest", padding: [0] }) : IteratorObject<[number] | [number, number | undefined], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>b1 : [Iterable] | [Iterable, Iterable] +>{ mode: "longest", padding: [0] } : { mode: "longest"; padding: [number]; } +>mode : "longest" +>"longest" : "longest" +>padding : [number] +>[0] : [number] +>0 : 0 +>toArray : () => ([number] | [number, number | undefined])[] + +const d1: number[][] = c1; +>d1 : number[][] +>c1 : ([number] | [number, number | undefined])[] + +declare const e1: { a: Iterable; } | { b: Iterable; }; +>e1 : { a: Iterable; } | { b: Iterable; } +>a : Iterable +>b : Iterable + +const f1 = Iterator.zipKeyed(e1, { mode: "longest", padding: { a: 0 } }).toArray(); +>f1 : ({ a: number; } | { b: string | undefined; })[] +>Iterator.zipKeyed(e1, { mode: "longest", padding: { a: 0 } }).toArray() : ({ a: number; } | { b: string | undefined; })[] +>Iterator.zipKeyed(e1, { mode: "longest", padding: { a: 0 } }).toArray : () => ({ a: number; } | { b: string | undefined; })[] +>Iterator.zipKeyed(e1, { mode: "longest", padding: { a: 0 } }) : IteratorObject<{ a: number; } | { b: string | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>e1 : { a: Iterable; } | { b: Iterable; } +>{ mode: "longest", padding: { a: 0 } } : { mode: "longest"; padding: { a: number; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: number; } +>{ a: 0 } : { a: number; } +>a : number +>0 : 0 +>toArray : () => ({ a: number; } | { b: string | undefined; })[] + +const g1: ({ a: number; } | { b: string; })[] = f1; +>g1 : ({ a: number; } | { b: string; })[] +>a : number +>b : string +>f1 : ({ a: number; } | { b: string | undefined; })[] + +declare const h1: { a: number; } | { b: string; }; +>h1 : { a: number; } | { b: string; } +>a : number +>b : string + +const i1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: h1 }).toArray(); +>i1 : { a: number | undefined; b: string | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: h1 }).toArray() : { a: number | undefined; b: string | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: h1 }).toArray : () => { a: number | undefined; b: string | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: h1 }) : IteratorObject<{ a: number | undefined; b: string | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : string[] +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: h1 } : { mode: "longest"; padding: { a: number; } | { b: string; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: number; } | { b: string; } +>h1 : { a: number; } | { b: string; } +>toArray : () => { a: number | undefined; b: string | undefined; }[] + +const j1: { a: number; b: string; }[] = i1; +>j1 : { a: number; b: string; }[] +>a : number +>b : string +>i1 : { a: number | undefined; b: string | undefined; }[] + +const k1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); +>k1 : { a: number | undefined; b: number; }[] +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray() : { a: number | undefined; b: number; }[] +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray : () => { a: number | undefined; b: number; }[] +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }) : IteratorObject<{ a: number | undefined; b: number; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>{ a: [1], b: [2] } : { a: number[]; b: number[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : number[] +>[2] : number[] +>2 : 2 +>{ mode: "longest", padding: { a: undefined, b: 0 } } : { mode: "longest"; padding: { a: undefined; b: number; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: undefined; b: number; } +>{ a: undefined, b: 0 } : { a: undefined; b: number; } +>a : undefined +>undefined : undefined +>b : number +>0 : 0 +>toArray : () => { a: number | undefined; b: number; }[] + +const l1: { a: number; b: number; }[] = k1; +>l1 : { a: number; b: number; }[] +>a : number +>b : number +>k1 : { a: number | undefined; b: number; }[] + +declare const m1: { [K in `a${string}`]: Iterable; }; +>m1 : { [x: `a${string}`]: Iterable; } + +const n1 = Iterator.zipKeyed(m1, { mode: "longest", padding: {} }).toArray(); +>n1 : { [x: `a${string}`]: number | undefined; }[] +>Iterator.zipKeyed(m1, { mode: "longest", padding: {} }).toArray() : { [x: `a${string}`]: number | undefined; }[] +>Iterator.zipKeyed(m1, { mode: "longest", padding: {} }).toArray : () => { [x: `a${string}`]: number | undefined; }[] +>Iterator.zipKeyed(m1, { mode: "longest", padding: {} }) : IteratorObject<{ [x: `a${string}`]: number | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>m1 : { [x: `a${string}`]: Iterable; } +>{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } +>mode : "longest" +>"longest" : "longest" +>padding : {} +>{} : {} +>toArray : () => { [x: `a${string}`]: number | undefined; }[] + +const o1: { [K in `a${string}`]: number; }[] = n1; +>o1 : { [x: `a${string}`]: number; }[] +>n1 : { [x: `a${string}`]: number | undefined; }[] + +declare const p1: unique symbol; +>p1 : unique symbol + +const q1: { [p1]: number; }[] = Iterator.zipKeyed({ [p1]: [1] }, { mode: "longest", padding: { [p1]: 0 } }).toArray(); +>q1 : { [p1]: number; }[] +>[p1] : number +>p1 : unique symbol +>Iterator.zipKeyed({ [p1]: [1] }, { mode: "longest", padding: { [p1]: 0 } }).toArray() : { [p1]: number; }[] +>Iterator.zipKeyed({ [p1]: [1] }, { mode: "longest", padding: { [p1]: 0 } }).toArray : () => { [p1]: number; }[] +>Iterator.zipKeyed({ [p1]: [1] }, { mode: "longest", padding: { [p1]: 0 } }) : IteratorObject<{ [p1]: number; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>{ [p1]: [1] } : { [p1]: number[]; } +>[p1] : number[] +>p1 : unique symbol +>[1] : number[] +>1 : 1 +>{ mode: "longest", padding: { [p1]: 0 } } : { mode: "longest"; padding: { [p1]: number; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { [p1]: number; } +>{ [p1]: 0 } : { [p1]: number; } +>[p1] : number +>p1 : unique symbol +>0 : 0 +>toArray : () => { [p1]: number; }[] + +declare const r1: Record & { a: number; }; +>r1 : Record & { a: number; } +>a : number + +const s1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: r1 }).toArray(); +>s1 : { a: number; b: number | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: r1 }).toArray() : { a: number; b: number | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: r1 }).toArray : () => { a: number; b: number | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: r1 }) : IteratorObject<{ a: number; b: number | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>{ a: [1], b: [2] } : { a: number[]; b: number[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : number[] +>[2] : number[] +>2 : 2 +>{ mode: "longest", padding: r1 } : { mode: "longest"; padding: Record & { a: number; }; } +>mode : "longest" +>"longest" : "longest" +>padding : Record & { a: number; } +>r1 : Record & { a: number; } +>toArray : () => { a: number; b: number | undefined; }[] + +const t1: { a: number; b: number | undefined; }[] = s1; +>t1 : { a: number; b: number | undefined; }[] +>a : number +>b : number | undefined +>s1 : { a: number; b: number | undefined; }[] + +const u1: { a: number; b: number; }[] = s1; +>u1 : { a: number; b: number; }[] +>a : number +>b : number +>s1 : { a: number; b: number | undefined; }[] + +declare const v1: [number] | [number, string]; +>v1 : [number] | [number, string] + +const w1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: v1 }).toArray(); +>w1 : [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: v1 }).toArray() : [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: v1 }).toArray : () => [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: v1 }) : IteratorObject<[number, string | undefined], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] : [number[], string[]] +>[1] : number[] +>1 : 1 +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: v1 } : { mode: "longest"; padding: [number] | [number, string]; } +>mode : "longest" +>"longest" : "longest" +>padding : [number] | [number, string] +>v1 : [number] | [number, string] +>toArray : () => [number, string | undefined][] + +const x1: [number, string | undefined][] = w1; +>x1 : [number, string | undefined][] +>w1 : [number, string | undefined][] + +const y1: [number, string][] = w1; +>y1 : [number, string][] +>w1 : [number, string | undefined][] + +const z1: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); +>z1 : [number | undefined, number][] +>Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray() : [number | undefined, number][] +>Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray : () => [number | undefined, number][] +>Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }) : IteratorObject<[number | undefined, number], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], [2]] : [number[], number[]] +>[1] : number[] +>1 : 1 +>[2] : number[] +>2 : 2 +>{ mode: "longest", padding: [undefined, 0] } : { mode: "longest"; padding: [undefined, number]; } +>mode : "longest" +>"longest" : "longest" +>padding : [undefined, number] +>[undefined, 0] : [undefined, number] +>undefined : undefined +>0 : 0 +>toArray : () => [number | undefined, number][] + +const a2: { a: number | undefined; b: number; }[] = k1; +>a2 : { a: number | undefined; b: number; }[] +>a : number | undefined +>b : number +>k1 : { a: number | undefined; b: number; }[] + diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=true).errors.txt b/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=true).errors.txt new file mode 100644 index 0000000000000..4ba9821668036 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=true).errors.txt @@ -0,0 +1,215 @@ +iteratorZipPadding.ts(4,7): error TS2322: Type '[number, ...(number | undefined)[]][]' is not assignable to type 'number[][]'. + Type '[number, ...(number | undefined)[]]' is not assignable to type 'number[]'. + Type 'number | undefined' is not assignable to type 'number'. + Type 'undefined' is not assignable to type 'number'. +iteratorZipPadding.ts(9,7): error TS2322: Type 'IteratorZipResult<{ [x: string]: Iterable; } & {}, undefined, {}>[]' is not assignable to type 'Record[]'. + Type 'IteratorZipResult<{ [x: string]: Iterable; } & {}, undefined, {}>' is not assignable to type 'Record'. + 'string' index signatures are incompatible. + Type 'number | undefined' is not assignable to type 'number'. + Type 'undefined' is not assignable to type 'number'. +iteratorZipPadding.ts(14,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record>[]' is not assignable to type '{ a: number; b: number; }[]'. + Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record>' is not assignable to type '{ a: number; b: number; }'. + Types of property 'a' are incompatible. + Type 'number | undefined' is not assignable to type 'number'. + Type 'undefined' is not assignable to type 'number'. +iteratorZipPadding.ts(23,7): error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. + Type '[number, string | undefined]' is not assignable to type '[number, string]'. + Type at position 1 in source is not compatible with type at position 1 in target. + Type 'string | undefined' is not assignable to type 'string'. + Type 'undefined' is not assignable to type 'string'. +iteratorZipPadding.ts(26,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; }>[]' is not assignable to type '{ a: number; b: string; }[]'. + Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; b: string; }'. + Types of property 'b' are incompatible. + Type 'string | undefined' is not assignable to type 'string'. + Type 'undefined' is not assignable to type 'string'. +iteratorZipPadding.ts(32,7): error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. + Type '[number, string | undefined]' is not assignable to type '[number, string]'. + Type at position 1 in source is not compatible with type at position 1 in target. + Type 'string | undefined' is not assignable to type 'string'. + Type 'undefined' is not assignable to type 'string'. +iteratorZipPadding.ts(36,7): error TS2322: Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>[]' is not assignable to type 'number[][]'. + Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>' is not assignable to type 'number[]'. + Type '[number, number | undefined]' is not assignable to type 'number[]'. + Type 'number | undefined' is not assignable to type 'number'. + Type 'undefined' is not assignable to type 'number'. +iteratorZipPadding.ts(39,7): error TS2322: Type '(IteratorZipResult<{ a: Iterable; } & {}, undefined, { a: number; }> | IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>)[]' is not assignable to type '({ a: number; } | { b: string; })[]'. + Type 'IteratorZipResult<{ a: Iterable; } & {}, undefined, { a: number; }> | IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; } | { b: string; }'. + Type 'IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; } | { b: string; }'. + Type 'IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ b: string; }'. + Types of property 'b' are incompatible. + Type 'string | undefined' is not assignable to type 'string'. + Type 'undefined' is not assignable to type 'string'. +iteratorZipPadding.ts(43,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; } | { b: string; }>[]' is not assignable to type '{ a: number; b: string; }[]'. + Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; } | { b: string; }>' is not assignable to type '{ a: number; b: string; }'. + Types of property 'a' are incompatible. + Type 'number | undefined' is not assignable to type 'number'. + Type 'undefined' is not assignable to type 'number'. +iteratorZipPadding.ts(46,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, { a: undefined; b: number; }>[]' is not assignable to type '{ a: number; b: number; }[]'. + Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, { a: undefined; b: number; }>' is not assignable to type '{ a: number; b: number; }'. + Types of property 'a' are incompatible. + Type 'number | undefined' is not assignable to type 'number'. + Type 'undefined' is not assignable to type 'number'. +iteratorZipPadding.ts(50,7): error TS2322: Type 'IteratorZipResult<{ [x: `a${string}`]: Iterable; } & {}, undefined, {}>[]' is not assignable to type '{ [x: `a${string}`]: number; }[]'. + Type 'IteratorZipResult<{ [x: `a${string}`]: Iterable; } & {}, undefined, {}>' is not assignable to type '{ [x: `a${string}`]: number; }'. + '`a${string}`' index signatures are incompatible. + Type 'number | undefined' is not assignable to type 'number'. + Type 'undefined' is not assignable to type 'number'. +iteratorZipPadding.ts(58,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record & { a: number; }>[]' is not assignable to type '{ a: number; b: number; }[]'. + Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record & { a: number; }>' is not assignable to type '{ a: number; b: number; }'. + Types of property 'b' are incompatible. + Type 'number | undefined' is not assignable to type 'number'. + Type 'undefined' is not assignable to type 'number'. +iteratorZipPadding.ts(63,7): error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. + Type '[number, string | undefined]' is not assignable to type '[number, string]'. + Type at position 1 in source is not compatible with type at position 1 in target. + Type 'string | undefined' is not assignable to type 'string'. + Type 'undefined' is not assignable to type 'string'. + + +==== iteratorZipPadding.ts (13 errors) ==== + const a: [Iterable, ...Iterable[]] = [[1, 2], [3]]; + const b = Iterator.zip(a, { mode: "longest", padding: [0] }).toArray(); + const c: (number | undefined)[][] = b; + const d: number[][] = b; + ~ +!!! error TS2322: Type '[number, ...(number | undefined)[]][]' is not assignable to type 'number[][]'. +!!! error TS2322: Type '[number, ...(number | undefined)[]]' is not assignable to type 'number[]'. +!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'undefined' is not assignable to type 'number'. + + const e: Record> = { a: [1], b: [2, 3] }; + const f = Iterator.zipKeyed(e, { mode: "longest", padding: {} }).toArray(); + const g: Record[] = f; + const h: Record[] = f; + ~ +!!! error TS2322: Type 'IteratorZipResult<{ [x: string]: Iterable; } & {}, undefined, {}>[]' is not assignable to type 'Record[]'. +!!! error TS2322: Type 'IteratorZipResult<{ [x: string]: Iterable; } & {}, undefined, {}>' is not assignable to type 'Record'. +!!! error TS2322: 'string' index signatures are incompatible. +!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'undefined' is not assignable to type 'number'. + + declare const i: Record; + const j = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: i }).toArray(); + const k: { a: number | undefined; b: number | undefined; }[] = j; + const l: { a: number; b: number; }[] = j; + ~ +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record>[]' is not assignable to type '{ a: number; b: number; }[]'. +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record>' is not assignable to type '{ a: number; b: number; }'. +!!! error TS2322: Types of property 'a' are incompatible. +!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'undefined' is not assignable to type 'number'. + + const m = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); + const n: [number, string][] = m; + const o = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); + const p: { a: number; b: string; }[] = o; + + const q = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); + const r: [number | undefined, string | undefined][] = q; + const s: [number, string][] = q; + ~ +!!! error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. +!!! error TS2322: Type '[number, string | undefined]' is not assignable to type '[number, string]'. +!!! error TS2322: Type at position 1 in source is not compatible with type at position 1 in target. +!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. +!!! error TS2322: Type 'undefined' is not assignable to type 'string'. + const t = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); + const u: { a: number | undefined; b: string | undefined; }[] = t; + const v: { a: number; b: string; }[] = t; + ~ +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; }>[]' is not assignable to type '{ a: number; b: string; }[]'. +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; b: string; }'. +!!! error TS2322: Types of property 'b' are incompatible. +!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. +!!! error TS2322: Type 'undefined' is not assignable to type 'string'. + + declare const w: readonly [number, string]; + const x: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: w }).toArray(); + declare const y: [number, string?]; + const z = Iterator.zip([[1], ["a"]], { mode: "longest", padding: y }).toArray(); + const a1: [number, string][] = z; + ~~ +!!! error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. +!!! error TS2322: Type '[number, string | undefined]' is not assignable to type '[number, string]'. +!!! error TS2322: Type at position 1 in source is not compatible with type at position 1 in target. +!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. +!!! error TS2322: Type 'undefined' is not assignable to type 'string'. + + declare const b1: [Iterable] | [Iterable, Iterable]; + const c1 = Iterator.zip(b1, { mode: "longest", padding: [0] }).toArray(); + const d1: number[][] = c1; + ~~ +!!! error TS2322: Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>[]' is not assignable to type 'number[][]'. +!!! error TS2322: Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>' is not assignable to type 'number[]'. +!!! error TS2322: Type '[number, number | undefined]' is not assignable to type 'number[]'. +!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'undefined' is not assignable to type 'number'. + declare const e1: { a: Iterable; } | { b: Iterable; }; + const f1 = Iterator.zipKeyed(e1, { mode: "longest", padding: { a: 0 } }).toArray(); + const g1: ({ a: number; } | { b: string; })[] = f1; + ~~ +!!! error TS2322: Type '(IteratorZipResult<{ a: Iterable; } & {}, undefined, { a: number; }> | IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>)[]' is not assignable to type '({ a: number; } | { b: string; })[]'. +!!! error TS2322: Type 'IteratorZipResult<{ a: Iterable; } & {}, undefined, { a: number; }> | IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; } | { b: string; }'. +!!! error TS2322: Type 'IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; } | { b: string; }'. +!!! error TS2322: Type 'IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ b: string; }'. +!!! error TS2322: Types of property 'b' are incompatible. +!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. +!!! error TS2322: Type 'undefined' is not assignable to type 'string'. + + declare const h1: { a: number; } | { b: string; }; + const i1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: h1 }).toArray(); + const j1: { a: number; b: string; }[] = i1; + ~~ +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; } | { b: string; }>[]' is not assignable to type '{ a: number; b: string; }[]'. +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; } | { b: string; }>' is not assignable to type '{ a: number; b: string; }'. +!!! error TS2322: Types of property 'a' are incompatible. +!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'undefined' is not assignable to type 'number'. + + const k1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); + const l1: { a: number; b: number; }[] = k1; + ~~ +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, { a: undefined; b: number; }>[]' is not assignable to type '{ a: number; b: number; }[]'. +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, { a: undefined; b: number; }>' is not assignable to type '{ a: number; b: number; }'. +!!! error TS2322: Types of property 'a' are incompatible. +!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'undefined' is not assignable to type 'number'. + + declare const m1: { [K in `a${string}`]: Iterable; }; + const n1 = Iterator.zipKeyed(m1, { mode: "longest", padding: {} }).toArray(); + const o1: { [K in `a${string}`]: number; }[] = n1; + ~~ +!!! error TS2322: Type 'IteratorZipResult<{ [x: `a${string}`]: Iterable; } & {}, undefined, {}>[]' is not assignable to type '{ [x: `a${string}`]: number; }[]'. +!!! error TS2322: Type 'IteratorZipResult<{ [x: `a${string}`]: Iterable; } & {}, undefined, {}>' is not assignable to type '{ [x: `a${string}`]: number; }'. +!!! error TS2322: '`a${string}`' index signatures are incompatible. +!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'undefined' is not assignable to type 'number'. + + declare const p1: unique symbol; + const q1: { [p1]: number; }[] = Iterator.zipKeyed({ [p1]: [1] }, { mode: "longest", padding: { [p1]: 0 } }).toArray(); + + declare const r1: Record & { a: number; }; + const s1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: r1 }).toArray(); + const t1: { a: number; b: number | undefined; }[] = s1; + const u1: { a: number; b: number; }[] = s1; + ~~ +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record & { a: number; }>[]' is not assignable to type '{ a: number; b: number; }[]'. +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record & { a: number; }>' is not assignable to type '{ a: number; b: number; }'. +!!! error TS2322: Types of property 'b' are incompatible. +!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'undefined' is not assignable to type 'number'. + + declare const v1: [number] | [number, string]; + const w1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: v1 }).toArray(); + const x1: [number, string | undefined][] = w1; + const y1: [number, string][] = w1; + ~~ +!!! error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. +!!! error TS2322: Type '[number, string | undefined]' is not assignable to type '[number, string]'. +!!! error TS2322: Type at position 1 in source is not compatible with type at position 1 in target. +!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. +!!! error TS2322: Type 'undefined' is not assignable to type 'string'. + + const z1: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); + const a2: { a: number | undefined; b: number; }[] = k1; + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=true).js b/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=true).js new file mode 100644 index 0000000000000..408ebf1bc1fac --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=true).js @@ -0,0 +1,248 @@ +//// [tests/cases/compiler/iteratorZipPadding.ts] //// + +//// [iteratorZipPadding.ts] +const a: [Iterable, ...Iterable[]] = [[1, 2], [3]]; +const b = Iterator.zip(a, { mode: "longest", padding: [0] }).toArray(); +const c: (number | undefined)[][] = b; +const d: number[][] = b; + +const e: Record> = { a: [1], b: [2, 3] }; +const f = Iterator.zipKeyed(e, { mode: "longest", padding: {} }).toArray(); +const g: Record[] = f; +const h: Record[] = f; + +declare const i: Record; +const j = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: i }).toArray(); +const k: { a: number | undefined; b: number | undefined; }[] = j; +const l: { a: number; b: number; }[] = j; + +const m = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); +const n: [number, string][] = m; +const o = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); +const p: { a: number; b: string; }[] = o; + +const q = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); +const r: [number | undefined, string | undefined][] = q; +const s: [number, string][] = q; +const t = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); +const u: { a: number | undefined; b: string | undefined; }[] = t; +const v: { a: number; b: string; }[] = t; + +declare const w: readonly [number, string]; +const x: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: w }).toArray(); +declare const y: [number, string?]; +const z = Iterator.zip([[1], ["a"]], { mode: "longest", padding: y }).toArray(); +const a1: [number, string][] = z; + +declare const b1: [Iterable] | [Iterable, Iterable]; +const c1 = Iterator.zip(b1, { mode: "longest", padding: [0] }).toArray(); +const d1: number[][] = c1; +declare const e1: { a: Iterable; } | { b: Iterable; }; +const f1 = Iterator.zipKeyed(e1, { mode: "longest", padding: { a: 0 } }).toArray(); +const g1: ({ a: number; } | { b: string; })[] = f1; + +declare const h1: { a: number; } | { b: string; }; +const i1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: h1 }).toArray(); +const j1: { a: number; b: string; }[] = i1; + +const k1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); +const l1: { a: number; b: number; }[] = k1; + +declare const m1: { [K in `a${string}`]: Iterable; }; +const n1 = Iterator.zipKeyed(m1, { mode: "longest", padding: {} }).toArray(); +const o1: { [K in `a${string}`]: number; }[] = n1; + +declare const p1: unique symbol; +const q1: { [p1]: number; }[] = Iterator.zipKeyed({ [p1]: [1] }, { mode: "longest", padding: { [p1]: 0 } }).toArray(); + +declare const r1: Record & { a: number; }; +const s1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: r1 }).toArray(); +const t1: { a: number; b: number | undefined; }[] = s1; +const u1: { a: number; b: number; }[] = s1; + +declare const v1: [number] | [number, string]; +const w1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: v1 }).toArray(); +const x1: [number, string | undefined][] = w1; +const y1: [number, string][] = w1; + +const z1: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); +const a2: { a: number | undefined; b: number; }[] = k1; + + +//// [iteratorZipPadding.js] +"use strict"; +const a = [[1, 2], [3]]; +const b = Iterator.zip(a, { mode: "longest", padding: [0] }).toArray(); +const c = b; +const d = b; +const e = { a: [1], b: [2, 3] }; +const f = Iterator.zipKeyed(e, { mode: "longest", padding: {} }).toArray(); +const g = f; +const h = f; +const j = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: i }).toArray(); +const k = j; +const l = j; +const m = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); +const n = m; +const o = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); +const p = o; +const q = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); +const r = q; +const s = q; +const t = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); +const u = t; +const v = t; +const x = Iterator.zip([[1], ["a"]], { mode: "longest", padding: w }).toArray(); +const z = Iterator.zip([[1], ["a"]], { mode: "longest", padding: y }).toArray(); +const a1 = z; +const c1 = Iterator.zip(b1, { mode: "longest", padding: [0] }).toArray(); +const d1 = c1; +const f1 = Iterator.zipKeyed(e1, { mode: "longest", padding: { a: 0 } }).toArray(); +const g1 = f1; +const i1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: h1 }).toArray(); +const j1 = i1; +const k1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); +const l1 = k1; +const n1 = Iterator.zipKeyed(m1, { mode: "longest", padding: {} }).toArray(); +const o1 = n1; +const q1 = Iterator.zipKeyed({ [p1]: [1] }, { mode: "longest", padding: { [p1]: 0 } }).toArray(); +const s1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: r1 }).toArray(); +const t1 = s1; +const u1 = s1; +const w1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: v1 }).toArray(); +const x1 = w1; +const y1 = w1; +const z1 = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); +const a2 = k1; + + +//// [iteratorZipPadding.d.ts] +declare const a: [Iterable, ...Iterable[]]; +declare const b: [number, ...(number | undefined)[]][]; +declare const c: (number | undefined)[][]; +declare const d: number[][]; +declare const e: Record>; +declare const f: { + [x: string]: number | undefined; +}[]; +declare const g: Record[]; +declare const h: Record[]; +declare const i: Record; +declare const j: { + a: number | undefined; + b: number | undefined; +}[]; +declare const k: { + a: number | undefined; + b: number | undefined; +}[]; +declare const l: { + a: number; + b: number; +}[]; +declare const m: [number, string][]; +declare const n: [number, string][]; +declare const o: { + a: number; + b: string; +}[]; +declare const p: { + a: number; + b: string; +}[]; +declare const q: [number, string | undefined][]; +declare const r: [number | undefined, string | undefined][]; +declare const s: [number, string][]; +declare const t: { + a: number; + b: string | undefined; +}[]; +declare const u: { + a: number | undefined; + b: string | undefined; +}[]; +declare const v: { + a: number; + b: string; +}[]; +declare const w: readonly [number, string]; +declare const x: [number, string][]; +declare const y: [number, string?]; +declare const z: [number, string | undefined][]; +declare const a1: [number, string][]; +declare const b1: [Iterable] | [Iterable, Iterable]; +declare const c1: ([number] | [number, number | undefined])[]; +declare const d1: number[][]; +declare const e1: { + a: Iterable; +} | { + b: Iterable; +}; +declare const f1: ({ + a: number; +} | { + b: string | undefined; +})[]; +declare const g1: ({ + a: number; +} | { + b: string; +})[]; +declare const h1: { + a: number; +} | { + b: string; +}; +declare const i1: { + a: number | undefined; + b: string | undefined; +}[]; +declare const j1: { + a: number; + b: string; +}[]; +declare const k1: { + a: number | undefined; + b: number; +}[]; +declare const l1: { + a: number; + b: number; +}[]; +declare const m1: { + [K in `a${string}`]: Iterable; +}; +declare const n1: { + [x: `a${string}`]: number | undefined; +}[]; +declare const o1: { + [K in `a${string}`]: number; +}[]; +declare const p1: unique symbol; +declare const q1: { + [p1]: number; +}[]; +declare const r1: Record & { + a: number; +}; +declare const s1: { + a: number; + b: number | undefined; +}[]; +declare const t1: { + a: number; + b: number | undefined; +}[]; +declare const u1: { + a: number; + b: number; +}[]; +declare const v1: [number] | [number, string]; +declare const w1: [number, string | undefined][]; +declare const x1: [number, string | undefined][]; +declare const y1: [number, string][]; +declare const z1: [number | undefined, number][]; +declare const a2: { + a: number | undefined; + b: number; +}[]; diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=true).symbols b/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=true).symbols new file mode 100644 index 0000000000000..7284c5da3fbf8 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=true).symbols @@ -0,0 +1,393 @@ +//// [tests/cases/compiler/iteratorZipPadding.ts] //// + +=== iteratorZipPadding.ts === +const a: [Iterable, ...Iterable[]] = [[1, 2], [3]]; +>a : Symbol(a, Decl(iteratorZipPadding.ts, 0, 5)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + +const b = Iterator.zip(a, { mode: "longest", padding: [0] }).toArray(); +>b : Symbol(b, Decl(iteratorZipPadding.ts, 1, 5)) +>Iterator.zip(a, { mode: "longest", padding: [0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 0, 5)) +>mode : Symbol(mode, Decl(iteratorZipPadding.ts, 1, 27)) +>padding : Symbol(padding, Decl(iteratorZipPadding.ts, 1, 44)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const c: (number | undefined)[][] = b; +>c : Symbol(c, Decl(iteratorZipPadding.ts, 2, 5)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 1, 5)) + +const d: number[][] = b; +>d : Symbol(d, Decl(iteratorZipPadding.ts, 3, 5)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 1, 5)) + +const e: Record> = { a: [1], b: [2, 3] }; +>e : Symbol(e, Decl(iteratorZipPadding.ts, 5, 5)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 5, 45)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 5, 53)) + +const f = Iterator.zipKeyed(e, { mode: "longest", padding: {} }).toArray(); +>f : Symbol(f, Decl(iteratorZipPadding.ts, 6, 5)) +>Iterator.zipKeyed(e, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>e : Symbol(e, Decl(iteratorZipPadding.ts, 5, 5)) +>mode : Symbol(mode, Decl(iteratorZipPadding.ts, 6, 32)) +>padding : Symbol(padding, Decl(iteratorZipPadding.ts, 6, 49)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const g: Record[] = f; +>g : Symbol(g, Decl(iteratorZipPadding.ts, 7, 5)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>f : Symbol(f, Decl(iteratorZipPadding.ts, 6, 5)) + +const h: Record[] = f; +>h : Symbol(h, Decl(iteratorZipPadding.ts, 8, 5)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>f : Symbol(f, Decl(iteratorZipPadding.ts, 6, 5)) + +declare const i: Record; +>i : Symbol(i, Decl(iteratorZipPadding.ts, 10, 13)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) + +const j = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: i }).toArray(); +>j : Symbol(j, Decl(iteratorZipPadding.ts, 11, 5)) +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: i }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 11, 29)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 11, 37)) +>mode : Symbol(mode, Decl(iteratorZipPadding.ts, 11, 52)) +>padding : Symbol(padding, Decl(iteratorZipPadding.ts, 11, 69)) +>i : Symbol(i, Decl(iteratorZipPadding.ts, 10, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const k: { a: number | undefined; b: number | undefined; }[] = j; +>k : Symbol(k, Decl(iteratorZipPadding.ts, 12, 5)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 12, 10)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 12, 33)) +>j : Symbol(j, Decl(iteratorZipPadding.ts, 11, 5)) + +const l: { a: number; b: number; }[] = j; +>l : Symbol(l, Decl(iteratorZipPadding.ts, 13, 5)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 13, 10)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 13, 21)) +>j : Symbol(j, Decl(iteratorZipPadding.ts, 11, 5)) + +const m = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); +>m : Symbol(m, Decl(iteratorZipPadding.ts, 15, 5)) +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZipPadding.ts, 15, 38)) +>padding : Symbol(padding, Decl(iteratorZipPadding.ts, 15, 55)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const n: [number, string][] = m; +>n : Symbol(n, Decl(iteratorZipPadding.ts, 16, 5)) +>m : Symbol(m, Decl(iteratorZipPadding.ts, 15, 5)) + +const o = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); +>o : Symbol(o, Decl(iteratorZipPadding.ts, 17, 5)) +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 17, 29)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 17, 37)) +>mode : Symbol(mode, Decl(iteratorZipPadding.ts, 17, 51)) +>padding : Symbol(padding, Decl(iteratorZipPadding.ts, 17, 68)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 17, 79)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 17, 85)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const p: { a: number; b: string; }[] = o; +>p : Symbol(p, Decl(iteratorZipPadding.ts, 18, 5)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 18, 10)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 18, 21)) +>o : Symbol(o, Decl(iteratorZipPadding.ts, 17, 5)) + +const q = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); +>q : Symbol(q, Decl(iteratorZipPadding.ts, 20, 5)) +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZipPadding.ts, 20, 38)) +>padding : Symbol(padding, Decl(iteratorZipPadding.ts, 20, 55)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const r: [number | undefined, string | undefined][] = q; +>r : Symbol(r, Decl(iteratorZipPadding.ts, 21, 5)) +>q : Symbol(q, Decl(iteratorZipPadding.ts, 20, 5)) + +const s: [number, string][] = q; +>s : Symbol(s, Decl(iteratorZipPadding.ts, 22, 5)) +>q : Symbol(q, Decl(iteratorZipPadding.ts, 20, 5)) + +const t = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); +>t : Symbol(t, Decl(iteratorZipPadding.ts, 23, 5)) +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 23, 29)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 23, 37)) +>mode : Symbol(mode, Decl(iteratorZipPadding.ts, 23, 51)) +>padding : Symbol(padding, Decl(iteratorZipPadding.ts, 23, 68)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 23, 79)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const u: { a: number | undefined; b: string | undefined; }[] = t; +>u : Symbol(u, Decl(iteratorZipPadding.ts, 24, 5)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 24, 10)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 24, 33)) +>t : Symbol(t, Decl(iteratorZipPadding.ts, 23, 5)) + +const v: { a: number; b: string; }[] = t; +>v : Symbol(v, Decl(iteratorZipPadding.ts, 25, 5)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 25, 10)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 25, 21)) +>t : Symbol(t, Decl(iteratorZipPadding.ts, 23, 5)) + +declare const w: readonly [number, string]; +>w : Symbol(w, Decl(iteratorZipPadding.ts, 27, 13)) + +const x: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: w }).toArray(); +>x : Symbol(x, Decl(iteratorZipPadding.ts, 28, 5)) +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: w }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZipPadding.ts, 28, 58)) +>padding : Symbol(padding, Decl(iteratorZipPadding.ts, 28, 75)) +>w : Symbol(w, Decl(iteratorZipPadding.ts, 27, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const y: [number, string?]; +>y : Symbol(y, Decl(iteratorZipPadding.ts, 29, 13)) + +const z = Iterator.zip([[1], ["a"]], { mode: "longest", padding: y }).toArray(); +>z : Symbol(z, Decl(iteratorZipPadding.ts, 30, 5)) +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: y }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZipPadding.ts, 30, 38)) +>padding : Symbol(padding, Decl(iteratorZipPadding.ts, 30, 55)) +>y : Symbol(y, Decl(iteratorZipPadding.ts, 29, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a1: [number, string][] = z; +>a1 : Symbol(a1, Decl(iteratorZipPadding.ts, 31, 5)) +>z : Symbol(z, Decl(iteratorZipPadding.ts, 30, 5)) + +declare const b1: [Iterable] | [Iterable, Iterable]; +>b1 : Symbol(b1, Decl(iteratorZipPadding.ts, 33, 13)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + +const c1 = Iterator.zip(b1, { mode: "longest", padding: [0] }).toArray(); +>c1 : Symbol(c1, Decl(iteratorZipPadding.ts, 34, 5)) +>Iterator.zip(b1, { mode: "longest", padding: [0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>b1 : Symbol(b1, Decl(iteratorZipPadding.ts, 33, 13)) +>mode : Symbol(mode, Decl(iteratorZipPadding.ts, 34, 29)) +>padding : Symbol(padding, Decl(iteratorZipPadding.ts, 34, 46)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const d1: number[][] = c1; +>d1 : Symbol(d1, Decl(iteratorZipPadding.ts, 35, 5)) +>c1 : Symbol(c1, Decl(iteratorZipPadding.ts, 34, 5)) + +declare const e1: { a: Iterable; } | { b: Iterable; }; +>e1 : Symbol(e1, Decl(iteratorZipPadding.ts, 36, 13)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 36, 19)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 36, 46)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + +const f1 = Iterator.zipKeyed(e1, { mode: "longest", padding: { a: 0 } }).toArray(); +>f1 : Symbol(f1, Decl(iteratorZipPadding.ts, 37, 5)) +>Iterator.zipKeyed(e1, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>e1 : Symbol(e1, Decl(iteratorZipPadding.ts, 36, 13)) +>mode : Symbol(mode, Decl(iteratorZipPadding.ts, 37, 34)) +>padding : Symbol(padding, Decl(iteratorZipPadding.ts, 37, 51)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 37, 62)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const g1: ({ a: number; } | { b: string; })[] = f1; +>g1 : Symbol(g1, Decl(iteratorZipPadding.ts, 38, 5)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 38, 12)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 38, 29)) +>f1 : Symbol(f1, Decl(iteratorZipPadding.ts, 37, 5)) + +declare const h1: { a: number; } | { b: string; }; +>h1 : Symbol(h1, Decl(iteratorZipPadding.ts, 40, 13)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 40, 19)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 40, 36)) + +const i1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: h1 }).toArray(); +>i1 : Symbol(i1, Decl(iteratorZipPadding.ts, 41, 5)) +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: h1 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 41, 30)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 41, 38)) +>mode : Symbol(mode, Decl(iteratorZipPadding.ts, 41, 52)) +>padding : Symbol(padding, Decl(iteratorZipPadding.ts, 41, 69)) +>h1 : Symbol(h1, Decl(iteratorZipPadding.ts, 40, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const j1: { a: number; b: string; }[] = i1; +>j1 : Symbol(j1, Decl(iteratorZipPadding.ts, 42, 5)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 42, 11)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 42, 22)) +>i1 : Symbol(i1, Decl(iteratorZipPadding.ts, 41, 5)) + +const k1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); +>k1 : Symbol(k1, Decl(iteratorZipPadding.ts, 44, 5)) +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 44, 30)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 44, 38)) +>mode : Symbol(mode, Decl(iteratorZipPadding.ts, 44, 50)) +>padding : Symbol(padding, Decl(iteratorZipPadding.ts, 44, 67)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 44, 78)) +>undefined : Symbol(undefined) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 44, 92)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const l1: { a: number; b: number; }[] = k1; +>l1 : Symbol(l1, Decl(iteratorZipPadding.ts, 45, 5)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 45, 11)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 45, 22)) +>k1 : Symbol(k1, Decl(iteratorZipPadding.ts, 44, 5)) + +declare const m1: { [K in `a${string}`]: Iterable; }; +>m1 : Symbol(m1, Decl(iteratorZipPadding.ts, 47, 13)) +>K : Symbol(K, Decl(iteratorZipPadding.ts, 47, 21)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + +const n1 = Iterator.zipKeyed(m1, { mode: "longest", padding: {} }).toArray(); +>n1 : Symbol(n1, Decl(iteratorZipPadding.ts, 48, 5)) +>Iterator.zipKeyed(m1, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>m1 : Symbol(m1, Decl(iteratorZipPadding.ts, 47, 13)) +>mode : Symbol(mode, Decl(iteratorZipPadding.ts, 48, 34)) +>padding : Symbol(padding, Decl(iteratorZipPadding.ts, 48, 51)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const o1: { [K in `a${string}`]: number; }[] = n1; +>o1 : Symbol(o1, Decl(iteratorZipPadding.ts, 49, 5)) +>K : Symbol(K, Decl(iteratorZipPadding.ts, 49, 13)) +>n1 : Symbol(n1, Decl(iteratorZipPadding.ts, 48, 5)) + +declare const p1: unique symbol; +>p1 : Symbol(p1, Decl(iteratorZipPadding.ts, 51, 13)) + +const q1: { [p1]: number; }[] = Iterator.zipKeyed({ [p1]: [1] }, { mode: "longest", padding: { [p1]: 0 } }).toArray(); +>q1 : Symbol(q1, Decl(iteratorZipPadding.ts, 52, 5)) +>[p1] : Symbol([p1], Decl(iteratorZipPadding.ts, 52, 11)) +>p1 : Symbol(p1, Decl(iteratorZipPadding.ts, 51, 13)) +>Iterator.zipKeyed({ [p1]: [1] }, { mode: "longest", padding: { [p1]: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>[p1] : Symbol([p1], Decl(iteratorZipPadding.ts, 52, 51)) +>p1 : Symbol(p1, Decl(iteratorZipPadding.ts, 51, 13)) +>mode : Symbol(mode, Decl(iteratorZipPadding.ts, 52, 66)) +>padding : Symbol(padding, Decl(iteratorZipPadding.ts, 52, 83)) +>[p1] : Symbol([p1], Decl(iteratorZipPadding.ts, 52, 94)) +>p1 : Symbol(p1, Decl(iteratorZipPadding.ts, 51, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const r1: Record & { a: number; }; +>r1 : Symbol(r1, Decl(iteratorZipPadding.ts, 54, 13)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 54, 44)) + +const s1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: r1 }).toArray(); +>s1 : Symbol(s1, Decl(iteratorZipPadding.ts, 55, 5)) +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: r1 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 55, 30)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 55, 38)) +>mode : Symbol(mode, Decl(iteratorZipPadding.ts, 55, 50)) +>padding : Symbol(padding, Decl(iteratorZipPadding.ts, 55, 67)) +>r1 : Symbol(r1, Decl(iteratorZipPadding.ts, 54, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const t1: { a: number; b: number | undefined; }[] = s1; +>t1 : Symbol(t1, Decl(iteratorZipPadding.ts, 56, 5)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 56, 11)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 56, 22)) +>s1 : Symbol(s1, Decl(iteratorZipPadding.ts, 55, 5)) + +const u1: { a: number; b: number; }[] = s1; +>u1 : Symbol(u1, Decl(iteratorZipPadding.ts, 57, 5)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 57, 11)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 57, 22)) +>s1 : Symbol(s1, Decl(iteratorZipPadding.ts, 55, 5)) + +declare const v1: [number] | [number, string]; +>v1 : Symbol(v1, Decl(iteratorZipPadding.ts, 59, 13)) + +const w1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: v1 }).toArray(); +>w1 : Symbol(w1, Decl(iteratorZipPadding.ts, 60, 5)) +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: v1 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZipPadding.ts, 60, 39)) +>padding : Symbol(padding, Decl(iteratorZipPadding.ts, 60, 56)) +>v1 : Symbol(v1, Decl(iteratorZipPadding.ts, 59, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const x1: [number, string | undefined][] = w1; +>x1 : Symbol(x1, Decl(iteratorZipPadding.ts, 61, 5)) +>w1 : Symbol(w1, Decl(iteratorZipPadding.ts, 60, 5)) + +const y1: [number, string][] = w1; +>y1 : Symbol(y1, Decl(iteratorZipPadding.ts, 62, 5)) +>w1 : Symbol(w1, Decl(iteratorZipPadding.ts, 60, 5)) + +const z1: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); +>z1 : Symbol(z1, Decl(iteratorZipPadding.ts, 64, 5)) +>Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZipPadding.ts, 64, 69)) +>padding : Symbol(padding, Decl(iteratorZipPadding.ts, 64, 86)) +>undefined : Symbol(undefined) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a2: { a: number | undefined; b: number; }[] = k1; +>a2 : Symbol(a2, Decl(iteratorZipPadding.ts, 65, 5)) +>a : Symbol(a, Decl(iteratorZipPadding.ts, 65, 11)) +>b : Symbol(b, Decl(iteratorZipPadding.ts, 65, 34)) +>k1 : Symbol(k1, Decl(iteratorZipPadding.ts, 44, 5)) + diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=true).types b/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=true).types new file mode 100644 index 0000000000000..431cddbbc31a7 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=true).types @@ -0,0 +1,549 @@ +//// [tests/cases/compiler/iteratorZipPadding.ts] //// + +=== iteratorZipPadding.ts === +const a: [Iterable, ...Iterable[]] = [[1, 2], [3]]; +>a : [Iterable, ...Iterable[]] +>[[1, 2], [3]] : [number[], number[]] +>[1, 2] : number[] +>1 : 1 +>2 : 2 +>[3] : number[] +>3 : 3 + +const b = Iterator.zip(a, { mode: "longest", padding: [0] }).toArray(); +>b : [number, ...(number | undefined)[]][] +>Iterator.zip(a, { mode: "longest", padding: [0] }).toArray() : [number, ...(number | undefined)[]][] +>Iterator.zip(a, { mode: "longest", padding: [0] }).toArray : () => [number, ...(number | undefined)[]][] +>Iterator.zip(a, { mode: "longest", padding: [0] }) : IteratorObject<[number, ...(number | undefined)[]], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>a : [Iterable, ...Iterable[]] +>{ mode: "longest", padding: [0] } : { mode: "longest"; padding: [number]; } +>mode : "longest" +>"longest" : "longest" +>padding : [number] +>[0] : [number] +>0 : 0 +>toArray : () => [number, ...(number | undefined)[]][] + +const c: (number | undefined)[][] = b; +>c : (number | undefined)[][] +>b : [number, ...(number | undefined)[]][] + +const d: number[][] = b; +>d : number[][] +>b : [number, ...(number | undefined)[]][] + +const e: Record> = { a: [1], b: [2, 3] }; +>e : Record> +>{ a: [1], b: [2, 3] } : { a: number[]; b: number[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : number[] +>[2, 3] : number[] +>2 : 2 +>3 : 3 + +const f = Iterator.zipKeyed(e, { mode: "longest", padding: {} }).toArray(); +>f : { [x: string]: number | undefined; }[] +>Iterator.zipKeyed(e, { mode: "longest", padding: {} }).toArray() : { [x: string]: number | undefined; }[] +>Iterator.zipKeyed(e, { mode: "longest", padding: {} }).toArray : () => { [x: string]: number | undefined; }[] +>Iterator.zipKeyed(e, { mode: "longest", padding: {} }) : IteratorObject<{ [x: string]: number | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>e : Record> +>{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } +>mode : "longest" +>"longest" : "longest" +>padding : {} +>{} : {} +>toArray : () => { [x: string]: number | undefined; }[] + +const g: Record[] = f; +>g : Record[] +>f : { [x: string]: number | undefined; }[] + +const h: Record[] = f; +>h : Record[] +>f : { [x: string]: number | undefined; }[] + +declare const i: Record; +>i : Record + +const j = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: i }).toArray(); +>j : { a: number | undefined; b: number | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: i }).toArray() : { a: number | undefined; b: number | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: i }).toArray : () => { a: number | undefined; b: number | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: i }) : IteratorObject<{ a: number | undefined; b: number | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>{ a: [1], b: [2, 3] } : { a: number[]; b: number[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : number[] +>[2, 3] : number[] +>2 : 2 +>3 : 3 +>{ mode: "longest", padding: i } : { mode: "longest"; padding: Record; } +>mode : "longest" +>"longest" : "longest" +>padding : Record +>i : Record +>toArray : () => { a: number | undefined; b: number | undefined; }[] + +const k: { a: number | undefined; b: number | undefined; }[] = j; +>k : { a: number | undefined; b: number | undefined; }[] +>a : number | undefined +>b : number | undefined +>j : { a: number | undefined; b: number | undefined; }[] + +const l: { a: number; b: number; }[] = j; +>l : { a: number; b: number; }[] +>a : number +>b : number +>j : { a: number | undefined; b: number | undefined; }[] + +const m = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); +>m : [number, string][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray() : [number, string][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray : () => [number, string][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }) : IteratorObject<[number, string], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] : [number[], string[]] +>[1] : number[] +>1 : 1 +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: [0, ""] } : { mode: "longest"; padding: [number, string]; } +>mode : "longest" +>"longest" : "longest" +>padding : [number, string] +>[0, ""] : [number, string] +>0 : 0 +>"" : "" +>toArray : () => [number, string][] + +const n: [number, string][] = m; +>n : [number, string][] +>m : [number, string][] + +const o = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); +>o : { a: number; b: string; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray() : { a: number; b: string; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray : () => { a: number; b: string; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }) : IteratorObject<{ a: number; b: string; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : string[] +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: { a: 0, b: "" } } : { mode: "longest"; padding: { a: number; b: string; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: number; b: string; } +>{ a: 0, b: "" } : { a: number; b: string; } +>a : number +>0 : 0 +>b : string +>"" : "" +>toArray : () => { a: number; b: string; }[] + +const p: { a: number; b: string; }[] = o; +>p : { a: number; b: string; }[] +>a : number +>b : string +>o : { a: number; b: string; }[] + +const q = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); +>q : [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray() : [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray : () => [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }) : IteratorObject<[number, string | undefined], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] : [number[], string[]] +>[1] : number[] +>1 : 1 +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: [0] } : { mode: "longest"; padding: [number]; } +>mode : "longest" +>"longest" : "longest" +>padding : [number] +>[0] : [number] +>0 : 0 +>toArray : () => [number, string | undefined][] + +const r: [number | undefined, string | undefined][] = q; +>r : [number | undefined, string | undefined][] +>q : [number, string | undefined][] + +const s: [number, string][] = q; +>s : [number, string][] +>q : [number, string | undefined][] + +const t = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); +>t : { a: number; b: string | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray() : { a: number; b: string | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray : () => { a: number; b: string | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }) : IteratorObject<{ a: number; b: string | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : string[] +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: { a: 0 } } : { mode: "longest"; padding: { a: number; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: number; } +>{ a: 0 } : { a: number; } +>a : number +>0 : 0 +>toArray : () => { a: number; b: string | undefined; }[] + +const u: { a: number | undefined; b: string | undefined; }[] = t; +>u : { a: number | undefined; b: string | undefined; }[] +>a : number | undefined +>b : string | undefined +>t : { a: number; b: string | undefined; }[] + +const v: { a: number; b: string; }[] = t; +>v : { a: number; b: string; }[] +>a : number +>b : string +>t : { a: number; b: string | undefined; }[] + +declare const w: readonly [number, string]; +>w : readonly [number, string] + +const x: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: w }).toArray(); +>x : [number, string][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: w }).toArray() : [number, string][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: w }).toArray : () => [number, string][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: w }) : IteratorObject<[number, string], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] : [number[], string[]] +>[1] : number[] +>1 : 1 +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: w } : { mode: "longest"; padding: readonly [number, string]; } +>mode : "longest" +>"longest" : "longest" +>padding : readonly [number, string] +>w : readonly [number, string] +>toArray : () => [number, string][] + +declare const y: [number, string?]; +>y : [number, string?] + +const z = Iterator.zip([[1], ["a"]], { mode: "longest", padding: y }).toArray(); +>z : [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: y }).toArray() : [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: y }).toArray : () => [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: y }) : IteratorObject<[number, string | undefined], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] : [number[], string[]] +>[1] : number[] +>1 : 1 +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: y } : { mode: "longest"; padding: [number, string?]; } +>mode : "longest" +>"longest" : "longest" +>padding : [number, string?] +>y : [number, string?] +>toArray : () => [number, string | undefined][] + +const a1: [number, string][] = z; +>a1 : [number, string][] +>z : [number, string | undefined][] + +declare const b1: [Iterable] | [Iterable, Iterable]; +>b1 : [Iterable] | [Iterable, Iterable] + +const c1 = Iterator.zip(b1, { mode: "longest", padding: [0] }).toArray(); +>c1 : ([number] | [number, number | undefined])[] +>Iterator.zip(b1, { mode: "longest", padding: [0] }).toArray() : ([number] | [number, number | undefined])[] +>Iterator.zip(b1, { mode: "longest", padding: [0] }).toArray : () => ([number] | [number, number | undefined])[] +>Iterator.zip(b1, { mode: "longest", padding: [0] }) : IteratorObject<[number] | [number, number | undefined], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>b1 : [Iterable] | [Iterable, Iterable] +>{ mode: "longest", padding: [0] } : { mode: "longest"; padding: [number]; } +>mode : "longest" +>"longest" : "longest" +>padding : [number] +>[0] : [number] +>0 : 0 +>toArray : () => ([number] | [number, number | undefined])[] + +const d1: number[][] = c1; +>d1 : number[][] +>c1 : ([number] | [number, number | undefined])[] + +declare const e1: { a: Iterable; } | { b: Iterable; }; +>e1 : { a: Iterable; } | { b: Iterable; } +>a : Iterable +>b : Iterable + +const f1 = Iterator.zipKeyed(e1, { mode: "longest", padding: { a: 0 } }).toArray(); +>f1 : ({ a: number; } | { b: string | undefined; })[] +>Iterator.zipKeyed(e1, { mode: "longest", padding: { a: 0 } }).toArray() : ({ a: number; } | { b: string | undefined; })[] +>Iterator.zipKeyed(e1, { mode: "longest", padding: { a: 0 } }).toArray : () => ({ a: number; } | { b: string | undefined; })[] +>Iterator.zipKeyed(e1, { mode: "longest", padding: { a: 0 } }) : IteratorObject<{ a: number; } | { b: string | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>e1 : { a: Iterable; } | { b: Iterable; } +>{ mode: "longest", padding: { a: 0 } } : { mode: "longest"; padding: { a: number; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: number; } +>{ a: 0 } : { a: number; } +>a : number +>0 : 0 +>toArray : () => ({ a: number; } | { b: string | undefined; })[] + +const g1: ({ a: number; } | { b: string; })[] = f1; +>g1 : ({ a: number; } | { b: string; })[] +>a : number +>b : string +>f1 : ({ a: number; } | { b: string | undefined; })[] + +declare const h1: { a: number; } | { b: string; }; +>h1 : { a: number; } | { b: string; } +>a : number +>b : string + +const i1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: h1 }).toArray(); +>i1 : { a: number | undefined; b: string | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: h1 }).toArray() : { a: number | undefined; b: string | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: h1 }).toArray : () => { a: number | undefined; b: string | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: h1 }) : IteratorObject<{ a: number | undefined; b: string | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : string[] +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: h1 } : { mode: "longest"; padding: { a: number; } | { b: string; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: number; } | { b: string; } +>h1 : { a: number; } | { b: string; } +>toArray : () => { a: number | undefined; b: string | undefined; }[] + +const j1: { a: number; b: string; }[] = i1; +>j1 : { a: number; b: string; }[] +>a : number +>b : string +>i1 : { a: number | undefined; b: string | undefined; }[] + +const k1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); +>k1 : { a: number | undefined; b: number; }[] +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray() : { a: number | undefined; b: number; }[] +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray : () => { a: number | undefined; b: number; }[] +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }) : IteratorObject<{ a: number | undefined; b: number; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>{ a: [1], b: [2] } : { a: number[]; b: number[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : number[] +>[2] : number[] +>2 : 2 +>{ mode: "longest", padding: { a: undefined, b: 0 } } : { mode: "longest"; padding: { a: undefined; b: number; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: undefined; b: number; } +>{ a: undefined, b: 0 } : { a: undefined; b: number; } +>a : undefined +>undefined : undefined +>b : number +>0 : 0 +>toArray : () => { a: number | undefined; b: number; }[] + +const l1: { a: number; b: number; }[] = k1; +>l1 : { a: number; b: number; }[] +>a : number +>b : number +>k1 : { a: number | undefined; b: number; }[] + +declare const m1: { [K in `a${string}`]: Iterable; }; +>m1 : { [x: `a${string}`]: Iterable; } + +const n1 = Iterator.zipKeyed(m1, { mode: "longest", padding: {} }).toArray(); +>n1 : { [x: `a${string}`]: number | undefined; }[] +>Iterator.zipKeyed(m1, { mode: "longest", padding: {} }).toArray() : { [x: `a${string}`]: number | undefined; }[] +>Iterator.zipKeyed(m1, { mode: "longest", padding: {} }).toArray : () => { [x: `a${string}`]: number | undefined; }[] +>Iterator.zipKeyed(m1, { mode: "longest", padding: {} }) : IteratorObject<{ [x: `a${string}`]: number | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>m1 : { [x: `a${string}`]: Iterable; } +>{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } +>mode : "longest" +>"longest" : "longest" +>padding : {} +>{} : {} +>toArray : () => { [x: `a${string}`]: number | undefined; }[] + +const o1: { [K in `a${string}`]: number; }[] = n1; +>o1 : { [x: `a${string}`]: number; }[] +>n1 : { [x: `a${string}`]: number | undefined; }[] + +declare const p1: unique symbol; +>p1 : unique symbol + +const q1: { [p1]: number; }[] = Iterator.zipKeyed({ [p1]: [1] }, { mode: "longest", padding: { [p1]: 0 } }).toArray(); +>q1 : { [p1]: number; }[] +>[p1] : number +>p1 : unique symbol +>Iterator.zipKeyed({ [p1]: [1] }, { mode: "longest", padding: { [p1]: 0 } }).toArray() : { [p1]: number; }[] +>Iterator.zipKeyed({ [p1]: [1] }, { mode: "longest", padding: { [p1]: 0 } }).toArray : () => { [p1]: number; }[] +>Iterator.zipKeyed({ [p1]: [1] }, { mode: "longest", padding: { [p1]: 0 } }) : IteratorObject<{ [p1]: number; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>{ [p1]: [1] } : { [p1]: number[]; } +>[p1] : number[] +>p1 : unique symbol +>[1] : number[] +>1 : 1 +>{ mode: "longest", padding: { [p1]: 0 } } : { mode: "longest"; padding: { [p1]: number; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { [p1]: number; } +>{ [p1]: 0 } : { [p1]: number; } +>[p1] : number +>p1 : unique symbol +>0 : 0 +>toArray : () => { [p1]: number; }[] + +declare const r1: Record & { a: number; }; +>r1 : Record & { a: number; } +>a : number + +const s1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: r1 }).toArray(); +>s1 : { a: number; b: number | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: r1 }).toArray() : { a: number; b: number | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: r1 }).toArray : () => { a: number; b: number | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: r1 }) : IteratorObject<{ a: number; b: number | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } +>{ a: [1], b: [2] } : { a: number[]; b: number[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : number[] +>[2] : number[] +>2 : 2 +>{ mode: "longest", padding: r1 } : { mode: "longest"; padding: Record & { a: number; }; } +>mode : "longest" +>"longest" : "longest" +>padding : Record & { a: number; } +>r1 : Record & { a: number; } +>toArray : () => { a: number; b: number | undefined; }[] + +const t1: { a: number; b: number | undefined; }[] = s1; +>t1 : { a: number; b: number | undefined; }[] +>a : number +>b : number | undefined +>s1 : { a: number; b: number | undefined; }[] + +const u1: { a: number; b: number; }[] = s1; +>u1 : { a: number; b: number; }[] +>a : number +>b : number +>s1 : { a: number; b: number | undefined; }[] + +declare const v1: [number] | [number, string]; +>v1 : [number] | [number, string] + +const w1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: v1 }).toArray(); +>w1 : [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: v1 }).toArray() : [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: v1 }).toArray : () => [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: v1 }) : IteratorObject<[number, string | undefined], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] : [number[], string[]] +>[1] : number[] +>1 : 1 +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: v1 } : { mode: "longest"; padding: [number] | [number, string]; } +>mode : "longest" +>"longest" : "longest" +>padding : [number] | [number, string] +>v1 : [number] | [number, string] +>toArray : () => [number, string | undefined][] + +const x1: [number, string | undefined][] = w1; +>x1 : [number, string | undefined][] +>w1 : [number, string | undefined][] + +const y1: [number, string][] = w1; +>y1 : [number, string][] +>w1 : [number, string | undefined][] + +const z1: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); +>z1 : [number | undefined, number][] +>Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray() : [number | undefined, number][] +>Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray : () => [number | undefined, number][] +>Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }) : IteratorObject<[number | undefined, number], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], [2]] : [number[], number[]] +>[1] : number[] +>1 : 1 +>[2] : number[] +>2 : 2 +>{ mode: "longest", padding: [undefined, 0] } : { mode: "longest"; padding: [undefined, number]; } +>mode : "longest" +>"longest" : "longest" +>padding : [undefined, number] +>[undefined, 0] : [undefined, number] +>undefined : undefined +>0 : 0 +>toArray : () => [number | undefined, number][] + +const a2: { a: number | undefined; b: number; }[] = k1; +>a2 : { a: number | undefined; b: number; }[] +>a : number | undefined +>b : number +>k1 : { a: number | undefined; b: number; }[] + diff --git a/tsc/testdata/tests/cases/compiler/iteratorZipInputs.ts b/tsc/testdata/tests/cases/compiler/iteratorZipInputs.ts new file mode 100644 index 0000000000000..9f0959bdb1788 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/iteratorZipInputs.ts @@ -0,0 +1,70 @@ +// @target: esnext +// @lib: es2015, esnext.iterator +// @strict: true +// @exactOptionalPropertyTypes: true, false +// @declaration: true + +Iterator.zip("ab"); +Iterator.zip(["ab"]); +Iterator.zip(new Set(["ab"])); +Iterator.zipKeyed("ab"); +Iterator.zipKeyed({ a: "ab" }); +Iterator.zip([], { mode: "longest", padding: "ab" }); +Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); +Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); + +const a: [string][] = Iterator.zip([new String("ab")]).toArray(); +const b: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); +const c: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); + +const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); +const e: { a: number; }[] = d; +d[0].b; +const f: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); +const g: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); + +interface I { + readonly a: Iterable; + readonly b?: Iterator; + readonly c: Iterable | undefined; + readonly d?: undefined; +} +declare const h: I; +const i = Iterator.zipKeyed(h).toArray(); +const j: { a: number; b?: string; c?: boolean; }[] = i; +i[0].a = 2; +i[0].b = "a"; +i[0].c = true; +i[0].d; +const k: { a: number; c: boolean; }[] = i; +const l: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); + +declare const m: { a: Iterable; } | { b: Iterator; }; +const n: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(m).toArray(); +declare const o: { a: Iterable; } | { b: number; }; +Iterator.zipKeyed(o); +Iterator.zipKeyed(o, { mode: "longest" }); +Iterator.zipKeyed(o, { mode: "longest", padding: {} }); +declare const p: { a?: Iterable; } | { b: string; }; +Iterator.zipKeyed(p); +declare const q: { a: Iterable; } | { b: undefined; }; +const r: { a: number; }[] = Iterator.zipKeyed(q).toArray(); + +declare const s: unique symbol; +declare const t: { a: Iterable; [s]?: Iterable; }; +const u: { a: number; [s]?: string; }[] = Iterator.zipKeyed(t).toArray(); + +Iterator.zipKeyed({ a: [1], b: null }); +Iterator.zipKeyed({ a: [1], b: false }); +Iterator.zip([undefined]); + +declare const v: { a?: undefined; }; +const w: never[] = Iterator.zipKeyed(v).toArray(); +const x: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); +const y: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); + +function f1(a: Iterable) { + const b: { a: T; }[] = Iterator.zipKeyed({ a }).toArray(); + const c: [T][] = Iterator.zip([a]).toArray(); + return { b, c }; +} diff --git a/tsc/testdata/tests/cases/compiler/iteratorZipPadding.ts b/tsc/testdata/tests/cases/compiler/iteratorZipPadding.ts new file mode 100644 index 0000000000000..28a94f7ba69a4 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/iteratorZipPadding.ts @@ -0,0 +1,72 @@ +// @target: esnext +// @lib: es2015, esnext.iterator +// @strict: true +// @exactOptionalPropertyTypes: true, false +// @declaration: true + +const a: [Iterable, ...Iterable[]] = [[1, 2], [3]]; +const b = Iterator.zip(a, { mode: "longest", padding: [0] }).toArray(); +const c: (number | undefined)[][] = b; +const d: number[][] = b; + +const e: Record> = { a: [1], b: [2, 3] }; +const f = Iterator.zipKeyed(e, { mode: "longest", padding: {} }).toArray(); +const g: Record[] = f; +const h: Record[] = f; + +declare const i: Record; +const j = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: i }).toArray(); +const k: { a: number | undefined; b: number | undefined; }[] = j; +const l: { a: number; b: number; }[] = j; + +const m = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); +const n: [number, string][] = m; +const o = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); +const p: { a: number; b: string; }[] = o; + +const q = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); +const r: [number | undefined, string | undefined][] = q; +const s: [number, string][] = q; +const t = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); +const u: { a: number | undefined; b: string | undefined; }[] = t; +const v: { a: number; b: string; }[] = t; + +declare const w: readonly [number, string]; +const x: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: w }).toArray(); +declare const y: [number, string?]; +const z = Iterator.zip([[1], ["a"]], { mode: "longest", padding: y }).toArray(); +const a1: [number, string][] = z; + +declare const b1: [Iterable] | [Iterable, Iterable]; +const c1 = Iterator.zip(b1, { mode: "longest", padding: [0] }).toArray(); +const d1: number[][] = c1; +declare const e1: { a: Iterable; } | { b: Iterable; }; +const f1 = Iterator.zipKeyed(e1, { mode: "longest", padding: { a: 0 } }).toArray(); +const g1: ({ a: number; } | { b: string; })[] = f1; + +declare const h1: { a: number; } | { b: string; }; +const i1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: h1 }).toArray(); +const j1: { a: number; b: string; }[] = i1; + +const k1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); +const l1: { a: number; b: number; }[] = k1; + +declare const m1: { [K in `a${string}`]: Iterable; }; +const n1 = Iterator.zipKeyed(m1, { mode: "longest", padding: {} }).toArray(); +const o1: { [K in `a${string}`]: number; }[] = n1; + +declare const p1: unique symbol; +const q1: { [p1]: number; }[] = Iterator.zipKeyed({ [p1]: [1] }, { mode: "longest", padding: { [p1]: 0 } }).toArray(); + +declare const r1: Record & { a: number; }; +const s1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: r1 }).toArray(); +const t1: { a: number; b: number | undefined; }[] = s1; +const u1: { a: number; b: number; }[] = s1; + +declare const v1: [number] | [number, string]; +const w1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: v1 }).toArray(); +const x1: [number, string | undefined][] = w1; +const y1: [number, string][] = w1; + +const z1: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); +const a2: { a: number | undefined; b: number; }[] = k1; From 46a6d9cae8cb25255a4dbf500d33caea26cbd88d Mon Sep 17 00:00:00 2001 From: Oleksandr Tarasiuk Date: Fri, 25 Sep 2026 13:45:23 +0300 Subject: [PATCH 5/8] add tests --- ...iteratorConstructorAugmentation.errors.txt | 36 +++++++++++ .../iteratorConstructorAugmentation.js | 43 +++++++++++++ .../iteratorConstructorAugmentation.symbols | 64 +++++++++++++++++++ .../iteratorConstructorAugmentation.types | 64 +++++++++++++++++++ .../iteratorConstructorAugmentation.ts | 21 ++++++ 5 files changed, 228 insertions(+) create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorConstructorAugmentation.errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorConstructorAugmentation.js create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorConstructorAugmentation.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorConstructorAugmentation.types create mode 100644 tsc/testdata/tests/cases/compiler/iteratorConstructorAugmentation.ts diff --git a/tsc/testdata/baselines/reference/compiler/iteratorConstructorAugmentation.errors.txt b/tsc/testdata/baselines/reference/compiler/iteratorConstructorAugmentation.errors.txt new file mode 100644 index 0000000000000..1f19032c575fa --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorConstructorAugmentation.errors.txt @@ -0,0 +1,36 @@ +iteratorConstructorAugmentation.ts(15,7): error TS2322: Type 'IteratorObject' is not assignable to type 'IteratorObject'. + Types of property 'map' are incompatible. + Type '(callbackfn: (value: number, index: number) => U) => IteratorObject' is not assignable to type '(callbackfn: (value: string, index: number) => U) => IteratorObject'. + Types of parameters 'callbackfn' and 'callbackfn' are incompatible. + Types of parameters 'value' and 'value' are incompatible. + Type 'number' is not assignable to type 'string'. +iteratorConstructorAugmentation.ts(16,15): error TS2345: Argument of type 'number' is not assignable to parameter of type 'Iterable | Iterator'. + + +==== iteratorConstructorAugmentation.ts (2 errors) ==== + interface IteratorConstructor { + f(): void; + } + + declare const a: Iterator; + declare const b: Iterable; + + const c: IteratorObject = Iterator.from(a); + const d: IteratorObject = Iterator.from(b); + const e = Iterator.from; + const f = Iterator.from; + + Iterator.f(); + + const g: IteratorObject = Iterator.from(a); + ~ +!!! error TS2322: Type 'IteratorObject' is not assignable to type 'IteratorObject'. +!!! error TS2322: Types of property 'map' are incompatible. +!!! error TS2322: Type '(callbackfn: (value: number, index: number) => U) => IteratorObject' is not assignable to type '(callbackfn: (value: string, index: number) => U) => IteratorObject'. +!!! error TS2322: Types of parameters 'callbackfn' and 'callbackfn' are incompatible. +!!! error TS2322: Types of parameters 'value' and 'value' are incompatible. +!!! error TS2322: Type 'number' is not assignable to type 'string'. + Iterator.from(1); + ~ +!!! error TS2345: Argument of type 'number' is not assignable to parameter of type 'Iterable | Iterator'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/iteratorConstructorAugmentation.js b/tsc/testdata/baselines/reference/compiler/iteratorConstructorAugmentation.js new file mode 100644 index 0000000000000..eb96df9b61c42 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorConstructorAugmentation.js @@ -0,0 +1,43 @@ +//// [tests/cases/compiler/iteratorConstructorAugmentation.ts] //// + +//// [iteratorConstructorAugmentation.ts] +interface IteratorConstructor { + f(): void; +} + +declare const a: Iterator; +declare const b: Iterable; + +const c: IteratorObject = Iterator.from(a); +const d: IteratorObject = Iterator.from(b); +const e = Iterator.from; +const f = Iterator.from; + +Iterator.f(); + +const g: IteratorObject = Iterator.from(a); +Iterator.from(1); + + +//// [iteratorConstructorAugmentation.js] +"use strict"; +const c = Iterator.from(a); +const d = Iterator.from(b); +const e = Iterator.from; +const f = Iterator.from; +Iterator.f(); +const g = Iterator.from(a); +Iterator.from(1); + + +//// [iteratorConstructorAugmentation.d.ts] +interface IteratorConstructor { + f(): void; +} +declare const a: Iterator; +declare const b: Iterable; +declare const c: IteratorObject; +declare const d: IteratorObject; +declare const e: (value: Iterable | Iterator) => IteratorObject; +declare const f: (value: Iterable | Iterator) => IteratorObject; +declare const g: IteratorObject; diff --git a/tsc/testdata/baselines/reference/compiler/iteratorConstructorAugmentation.symbols b/tsc/testdata/baselines/reference/compiler/iteratorConstructorAugmentation.symbols new file mode 100644 index 0000000000000..dbb51a8cc8349 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorConstructorAugmentation.symbols @@ -0,0 +1,64 @@ +//// [tests/cases/compiler/iteratorConstructorAugmentation.ts] //// + +=== iteratorConstructorAugmentation.ts === +interface IteratorConstructor { +>IteratorConstructor : Symbol(IteratorConstructor, Decl(iteratorConstructorAugmentation.ts, 0, 0), Decl(lib.es2025.iterator.d.ts, --, --)) + + f(): void; +>f : Symbol(IteratorConstructor.f, Decl(iteratorConstructorAugmentation.ts, 0, 31)) +} + +declare const a: Iterator; +>a : Symbol(a, Decl(iteratorConstructorAugmentation.ts, 4, 13)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const b: Iterable; +>b : Symbol(b, Decl(iteratorConstructorAugmentation.ts, 5, 13)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + +const c: IteratorObject = Iterator.from(a); +>c : Symbol(c, Decl(iteratorConstructorAugmentation.ts, 7, 5)) +>IteratorObject : Symbol(IteratorObject, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorConstructorAugmentation.ts, 4, 13)) + +const d: IteratorObject = Iterator.from(b); +>d : Symbol(d, Decl(iteratorConstructorAugmentation.ts, 8, 5)) +>IteratorObject : Symbol(IteratorObject, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) +>b : Symbol(b, Decl(iteratorConstructorAugmentation.ts, 5, 13)) + +const e = Iterator.from; +>e : Symbol(e, Decl(iteratorConstructorAugmentation.ts, 9, 5)) +>Iterator.from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) + +const f = Iterator.from; +>f : Symbol(f, Decl(iteratorConstructorAugmentation.ts, 10, 5)) +>Iterator.from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) + +Iterator.f(); +>Iterator.f : Symbol(IteratorConstructor.f, Decl(iteratorConstructorAugmentation.ts, 0, 31)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>f : Symbol(IteratorConstructor.f, Decl(iteratorConstructorAugmentation.ts, 0, 31)) + +const g: IteratorObject = Iterator.from(a); +>g : Symbol(g, Decl(iteratorConstructorAugmentation.ts, 14, 5)) +>IteratorObject : Symbol(IteratorObject, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorConstructorAugmentation.ts, 4, 13)) + +Iterator.from(1); +>Iterator.from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) + diff --git a/tsc/testdata/baselines/reference/compiler/iteratorConstructorAugmentation.types b/tsc/testdata/baselines/reference/compiler/iteratorConstructorAugmentation.types new file mode 100644 index 0000000000000..a70338d1fddd5 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorConstructorAugmentation.types @@ -0,0 +1,64 @@ +//// [tests/cases/compiler/iteratorConstructorAugmentation.ts] //// + +=== iteratorConstructorAugmentation.ts === +interface IteratorConstructor { + f(): void; +>f : () => void +} + +declare const a: Iterator; +>a : Iterator + +declare const b: Iterable; +>b : Iterable + +const c: IteratorObject = Iterator.from(a); +>c : IteratorObject +>Iterator.from(a) : IteratorObject +>Iterator.from : (value: Iterable | Iterator) => IteratorObject +>Iterator : IteratorConstructor +>from : (value: Iterable | Iterator) => IteratorObject +>a : Iterator + +const d: IteratorObject = Iterator.from(b); +>d : IteratorObject +>Iterator.from(b) : IteratorObject +>Iterator.from : (value: Iterable | Iterator) => IteratorObject +>Iterator : IteratorConstructor +>from : (value: Iterable | Iterator) => IteratorObject +>b : Iterable + +const e = Iterator.from; +>e : (value: Iterable | Iterator) => IteratorObject +>Iterator.from : (value: Iterable | Iterator) => IteratorObject +>Iterator : IteratorConstructor +>from : (value: Iterable | Iterator) => IteratorObject + +const f = Iterator.from; +>f : (value: Iterable | Iterator) => IteratorObject +>Iterator.from : (value: Iterable | Iterator) => IteratorObject +>Iterator.from : (value: Iterable | Iterator) => IteratorObject +>Iterator : IteratorConstructor +>from : (value: Iterable | Iterator) => IteratorObject + +Iterator.f(); +>Iterator.f() : void +>Iterator.f : () => void +>Iterator : IteratorConstructor +>f : () => void + +const g: IteratorObject = Iterator.from(a); +>g : IteratorObject +>Iterator.from(a) : IteratorObject +>Iterator.from : (value: Iterable | Iterator) => IteratorObject +>Iterator : IteratorConstructor +>from : (value: Iterable | Iterator) => IteratorObject +>a : Iterator + +Iterator.from(1); +>Iterator.from(1) : IteratorObject +>Iterator.from : (value: Iterable | Iterator) => IteratorObject +>Iterator : IteratorConstructor +>from : (value: Iterable | Iterator) => IteratorObject +>1 : 1 + diff --git a/tsc/testdata/tests/cases/compiler/iteratorConstructorAugmentation.ts b/tsc/testdata/tests/cases/compiler/iteratorConstructorAugmentation.ts new file mode 100644 index 0000000000000..bee673b8bb220 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/iteratorConstructorAugmentation.ts @@ -0,0 +1,21 @@ +// @target: es2015 +// @lib: es2015, es2025.iterator +// @strict: true +// @declaration: true + +interface IteratorConstructor { + f(): void; +} + +declare const a: Iterator; +declare const b: Iterable; + +const c: IteratorObject = Iterator.from(a); +const d: IteratorObject = Iterator.from(b); +const e = Iterator.from; +const f = Iterator.from; + +Iterator.f(); + +const g: IteratorObject = Iterator.from(a); +Iterator.from(1); From 20a6ddfe1debdb821cadd0173b74ba50415d70be Mon Sep 17 00:00:00 2001 From: Oleksandr Tarasiuk Date: Fri, 25 Sep 2026 13:45:23 +0300 Subject: [PATCH 6/8] add tests --- .../bundled/libs/lib.esnext.iterator.d.ts | 7 + ...iteratorConstructorAugmentation.errors.txt | 36 + .../iteratorConstructorAugmentation.js | 43 + .../iteratorConstructorAugmentation.symbols | 64 + .../iteratorConstructorAugmentation.types | 64 + ...actoptionalpropertytypes=false).errors.txt | 635 ++++++ ...orZip(exactoptionalpropertytypes=false).js | 762 +++++++ ...(exactoptionalpropertytypes=false).symbols | 1368 ++++++++++++ ...ip(exactoptionalpropertytypes=false).types | 1939 +++++++++++++++++ ...xactoptionalpropertytypes=true).errors.txt | 631 ++++++ ...torZip(exactoptionalpropertytypes=true).js | 762 +++++++ ...p(exactoptionalpropertytypes=true).symbols | 1368 ++++++++++++ ...Zip(exactoptionalpropertytypes=true).types | 1939 +++++++++++++++++ .../reference/compiler/iteratorZip.errors.txt | 130 -- .../reference/compiler/iteratorZip.js | 127 -- .../reference/compiler/iteratorZip.symbols | 361 --- .../reference/compiler/iteratorZip.types | 543 ----- ...actoptionalpropertytypes=false).errors.txt | 266 --- ...nputs(exactoptionalpropertytypes=false).js | 208 -- ...(exactoptionalpropertytypes=false).symbols | 388 ---- ...ts(exactoptionalpropertytypes=false).types | 511 ----- ...xactoptionalpropertytypes=true).errors.txt | 262 --- ...Inputs(exactoptionalpropertytypes=true).js | 208 -- ...s(exactoptionalpropertytypes=true).symbols | 388 ---- ...uts(exactoptionalpropertytypes=true).types | 511 ----- ...actoptionalpropertytypes=false).errors.txt | 215 -- ...dding(exactoptionalpropertytypes=false).js | 248 --- ...(exactoptionalpropertytypes=false).symbols | 393 ---- ...ng(exactoptionalpropertytypes=false).types | 549 ----- ...xactoptionalpropertytypes=true).errors.txt | 215 -- ...adding(exactoptionalpropertytypes=true).js | 248 --- ...g(exactoptionalpropertytypes=true).symbols | 393 ---- ...ing(exactoptionalpropertytypes=true).types | 549 ----- .../iteratorConstructorAugmentation.ts | 21 + .../tests/cases/compiler/iteratorZip.ts | 189 ++ .../tests/cases/compiler/iteratorZipInputs.ts | 70 - .../cases/compiler/iteratorZipPadding.ts | 72 - 37 files changed, 9828 insertions(+), 6855 deletions(-) create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorConstructorAugmentation.errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorConstructorAugmentation.js create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorConstructorAugmentation.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorConstructorAugmentation.types create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).js create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).types create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).js create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).types delete mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZip.errors.txt delete mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZip.js delete mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZip.symbols delete mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZip.types delete mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=false).errors.txt delete mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=false).js delete mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=false).symbols delete mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=false).types delete mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=true).errors.txt delete mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=true).js delete mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=true).symbols delete mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=true).types delete mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=false).errors.txt delete mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=false).js delete mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=false).symbols delete mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=false).types delete mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=true).errors.txt delete mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=true).js delete mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=true).symbols delete mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=true).types create mode 100644 tsc/testdata/tests/cases/compiler/iteratorConstructorAugmentation.ts delete mode 100644 tsc/testdata/tests/cases/compiler/iteratorZipInputs.ts delete mode 100644 tsc/testdata/tests/cases/compiler/iteratorZipPadding.ts diff --git a/tsc/internal/bundled/libs/lib.esnext.iterator.d.ts b/tsc/internal/bundled/libs/lib.esnext.iterator.d.ts index 47c59519dd81f..fbf1d0a8e1461 100644 --- a/tsc/internal/bundled/libs/lib.esnext.iterator.d.ts +++ b/tsc/internal/bundled/libs/lib.esnext.iterator.d.ts @@ -134,5 +134,12 @@ declare global { zipKeyed(iterables: T & IteratorZipKeyedInput, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; zipKeyed(iterables: T & IteratorZipKeyedInput, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer>; }): IteratorObject, undefined, unknown>; zipKeyed(iterables: T & IteratorZipKeyedInput, options: IteratorZipOptions & object>>): IteratorObject, undefined, unknown>; + + /** + * Accepts objects whose types include inherited or non-enumerable properties. + * Property ownership and enumerability are not represented in object types, so the result values are unknown. + * Iterator records use the preceding overloads to preserve their inferred result types. + */ + zipKeyed(iterables: T & ([T] extends [IteratorZipKeyedInput] ? never : unknown), options?: IteratorZipOptions): IteratorObject, undefined, unknown>; } } diff --git a/tsc/testdata/baselines/reference/compiler/iteratorConstructorAugmentation.errors.txt b/tsc/testdata/baselines/reference/compiler/iteratorConstructorAugmentation.errors.txt new file mode 100644 index 0000000000000..1f19032c575fa --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorConstructorAugmentation.errors.txt @@ -0,0 +1,36 @@ +iteratorConstructorAugmentation.ts(15,7): error TS2322: Type 'IteratorObject' is not assignable to type 'IteratorObject'. + Types of property 'map' are incompatible. + Type '(callbackfn: (value: number, index: number) => U) => IteratorObject' is not assignable to type '(callbackfn: (value: string, index: number) => U) => IteratorObject'. + Types of parameters 'callbackfn' and 'callbackfn' are incompatible. + Types of parameters 'value' and 'value' are incompatible. + Type 'number' is not assignable to type 'string'. +iteratorConstructorAugmentation.ts(16,15): error TS2345: Argument of type 'number' is not assignable to parameter of type 'Iterable | Iterator'. + + +==== iteratorConstructorAugmentation.ts (2 errors) ==== + interface IteratorConstructor { + f(): void; + } + + declare const a: Iterator; + declare const b: Iterable; + + const c: IteratorObject = Iterator.from(a); + const d: IteratorObject = Iterator.from(b); + const e = Iterator.from; + const f = Iterator.from; + + Iterator.f(); + + const g: IteratorObject = Iterator.from(a); + ~ +!!! error TS2322: Type 'IteratorObject' is not assignable to type 'IteratorObject'. +!!! error TS2322: Types of property 'map' are incompatible. +!!! error TS2322: Type '(callbackfn: (value: number, index: number) => U) => IteratorObject' is not assignable to type '(callbackfn: (value: string, index: number) => U) => IteratorObject'. +!!! error TS2322: Types of parameters 'callbackfn' and 'callbackfn' are incompatible. +!!! error TS2322: Types of parameters 'value' and 'value' are incompatible. +!!! error TS2322: Type 'number' is not assignable to type 'string'. + Iterator.from(1); + ~ +!!! error TS2345: Argument of type 'number' is not assignable to parameter of type 'Iterable | Iterator'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/iteratorConstructorAugmentation.js b/tsc/testdata/baselines/reference/compiler/iteratorConstructorAugmentation.js new file mode 100644 index 0000000000000..eb96df9b61c42 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorConstructorAugmentation.js @@ -0,0 +1,43 @@ +//// [tests/cases/compiler/iteratorConstructorAugmentation.ts] //// + +//// [iteratorConstructorAugmentation.ts] +interface IteratorConstructor { + f(): void; +} + +declare const a: Iterator; +declare const b: Iterable; + +const c: IteratorObject = Iterator.from(a); +const d: IteratorObject = Iterator.from(b); +const e = Iterator.from; +const f = Iterator.from; + +Iterator.f(); + +const g: IteratorObject = Iterator.from(a); +Iterator.from(1); + + +//// [iteratorConstructorAugmentation.js] +"use strict"; +const c = Iterator.from(a); +const d = Iterator.from(b); +const e = Iterator.from; +const f = Iterator.from; +Iterator.f(); +const g = Iterator.from(a); +Iterator.from(1); + + +//// [iteratorConstructorAugmentation.d.ts] +interface IteratorConstructor { + f(): void; +} +declare const a: Iterator; +declare const b: Iterable; +declare const c: IteratorObject; +declare const d: IteratorObject; +declare const e: (value: Iterable | Iterator) => IteratorObject; +declare const f: (value: Iterable | Iterator) => IteratorObject; +declare const g: IteratorObject; diff --git a/tsc/testdata/baselines/reference/compiler/iteratorConstructorAugmentation.symbols b/tsc/testdata/baselines/reference/compiler/iteratorConstructorAugmentation.symbols new file mode 100644 index 0000000000000..dbb51a8cc8349 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorConstructorAugmentation.symbols @@ -0,0 +1,64 @@ +//// [tests/cases/compiler/iteratorConstructorAugmentation.ts] //// + +=== iteratorConstructorAugmentation.ts === +interface IteratorConstructor { +>IteratorConstructor : Symbol(IteratorConstructor, Decl(iteratorConstructorAugmentation.ts, 0, 0), Decl(lib.es2025.iterator.d.ts, --, --)) + + f(): void; +>f : Symbol(IteratorConstructor.f, Decl(iteratorConstructorAugmentation.ts, 0, 31)) +} + +declare const a: Iterator; +>a : Symbol(a, Decl(iteratorConstructorAugmentation.ts, 4, 13)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const b: Iterable; +>b : Symbol(b, Decl(iteratorConstructorAugmentation.ts, 5, 13)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + +const c: IteratorObject = Iterator.from(a); +>c : Symbol(c, Decl(iteratorConstructorAugmentation.ts, 7, 5)) +>IteratorObject : Symbol(IteratorObject, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorConstructorAugmentation.ts, 4, 13)) + +const d: IteratorObject = Iterator.from(b); +>d : Symbol(d, Decl(iteratorConstructorAugmentation.ts, 8, 5)) +>IteratorObject : Symbol(IteratorObject, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) +>b : Symbol(b, Decl(iteratorConstructorAugmentation.ts, 5, 13)) + +const e = Iterator.from; +>e : Symbol(e, Decl(iteratorConstructorAugmentation.ts, 9, 5)) +>Iterator.from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) + +const f = Iterator.from; +>f : Symbol(f, Decl(iteratorConstructorAugmentation.ts, 10, 5)) +>Iterator.from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) + +Iterator.f(); +>Iterator.f : Symbol(IteratorConstructor.f, Decl(iteratorConstructorAugmentation.ts, 0, 31)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>f : Symbol(IteratorConstructor.f, Decl(iteratorConstructorAugmentation.ts, 0, 31)) + +const g: IteratorObject = Iterator.from(a); +>g : Symbol(g, Decl(iteratorConstructorAugmentation.ts, 14, 5)) +>IteratorObject : Symbol(IteratorObject, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorConstructorAugmentation.ts, 4, 13)) + +Iterator.from(1); +>Iterator.from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) + diff --git a/tsc/testdata/baselines/reference/compiler/iteratorConstructorAugmentation.types b/tsc/testdata/baselines/reference/compiler/iteratorConstructorAugmentation.types new file mode 100644 index 0000000000000..a70338d1fddd5 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorConstructorAugmentation.types @@ -0,0 +1,64 @@ +//// [tests/cases/compiler/iteratorConstructorAugmentation.ts] //// + +=== iteratorConstructorAugmentation.ts === +interface IteratorConstructor { + f(): void; +>f : () => void +} + +declare const a: Iterator; +>a : Iterator + +declare const b: Iterable; +>b : Iterable + +const c: IteratorObject = Iterator.from(a); +>c : IteratorObject +>Iterator.from(a) : IteratorObject +>Iterator.from : (value: Iterable | Iterator) => IteratorObject +>Iterator : IteratorConstructor +>from : (value: Iterable | Iterator) => IteratorObject +>a : Iterator + +const d: IteratorObject = Iterator.from(b); +>d : IteratorObject +>Iterator.from(b) : IteratorObject +>Iterator.from : (value: Iterable | Iterator) => IteratorObject +>Iterator : IteratorConstructor +>from : (value: Iterable | Iterator) => IteratorObject +>b : Iterable + +const e = Iterator.from; +>e : (value: Iterable | Iterator) => IteratorObject +>Iterator.from : (value: Iterable | Iterator) => IteratorObject +>Iterator : IteratorConstructor +>from : (value: Iterable | Iterator) => IteratorObject + +const f = Iterator.from; +>f : (value: Iterable | Iterator) => IteratorObject +>Iterator.from : (value: Iterable | Iterator) => IteratorObject +>Iterator.from : (value: Iterable | Iterator) => IteratorObject +>Iterator : IteratorConstructor +>from : (value: Iterable | Iterator) => IteratorObject + +Iterator.f(); +>Iterator.f() : void +>Iterator.f : () => void +>Iterator : IteratorConstructor +>f : () => void + +const g: IteratorObject = Iterator.from(a); +>g : IteratorObject +>Iterator.from(a) : IteratorObject +>Iterator.from : (value: Iterable | Iterator) => IteratorObject +>Iterator : IteratorConstructor +>from : (value: Iterable | Iterator) => IteratorObject +>a : Iterator + +Iterator.from(1); +>Iterator.from(1) : IteratorObject +>Iterator.from : (value: Iterable | Iterator) => IteratorObject +>Iterator : IteratorConstructor +>from : (value: Iterable | Iterator) => IteratorObject +>1 : 1 + diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).errors.txt b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).errors.txt new file mode 100644 index 0000000000000..06d9ee80ef1aa --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).errors.txt @@ -0,0 +1,635 @@ +iteratorZip.ts(62,23): error TS2769: No overload matches this call. + The last overload gave the following error. + Type '"invalid"' is not assignable to type '"longest" | "shortest" | "strict" | undefined'. +iteratorZip.ts(64,56): error TS2769: No overload matches this call. + The last overload gave the following error. + Type 'true[]' is not assignable to type 'Iterable<"a" | 1 | undefined> & object'. + Type 'true[]' is not assignable to type 'Iterable<"a" | 1 | undefined>'. + The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. + Type 'IteratorResult' is not assignable to type 'IteratorResult<"a" | 1 | undefined, any>'. + Type 'IteratorYieldResult' is not assignable to type 'IteratorResult<"a" | 1 | undefined, any>'. + Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult<"a" | 1 | undefined>'. + Type 'true' is not assignable to type '"a" | 1 | undefined'. +iteratorZip.ts(66,41): error TS2769: No overload matches this call. + The last overload gave the following error. + Object literal may only specify known properties, and 'padding' does not exist in type 'IteratorZipShortestOptions'. +iteratorZip.ts(68,14): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type 'number' is not assignable to parameter of type 'Iterable> & object'. + Type 'number' is not assignable to type 'Iterable>'. +iteratorZip.ts(80,14): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type 'string' is not assignable to parameter of type 'Iterable> & object'. + Type 'string' is not assignable to type 'Iterable>'. +iteratorZip.ts(81,14): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type 'string[]' is not assignable to parameter of type 'Iterable> & object'. + Type 'string[]' is not assignable to type 'Iterable>'. + The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. + Type 'IteratorResult' is not assignable to type 'IteratorResult, any>'. + Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>'. + Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>'. + Type 'string' is not assignable to type 'IteratorInput'. +iteratorZip.ts(82,14): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type 'Set' is not assignable to parameter of type 'Iterable> & object'. + Type 'Set' is not assignable to type 'Iterable>'. + The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. + Type 'IteratorResult' is not assignable to type 'IteratorResult, any>'. + Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>'. + Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>'. + Type 'string' is not assignable to type 'IteratorInput'. +iteratorZip.ts(83,19): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type '"ab"' is not assignable to parameter of type 'never'. +iteratorZip.ts(85,37): error TS2769: No overload matches this call. + The last overload gave the following error. + Type 'string' is not assignable to type 'Iterable & object'. + Type 'string' is not assignable to type 'Iterable'. +iteratorZip.ts(86,42): error TS2769: No overload matches this call. + The last overload gave the following error. + Type 'string' is not assignable to type 'Iterable & object'. + Type 'string' is not assignable to type 'object'. +iteratorZip.ts(87,19): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type '{}' is not assignable to parameter of type 'never'. +iteratorZip.ts(95,6): error TS2339: Property 'b' does not exist on type 'IteratorZipResult<{ a: number[]; } & {}, never, {}>'. +iteratorZip.ts(111,6): error TS2339: Property 'd' does not exist on type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator | undefined; readonly c?: Iterable | undefined; }, never, {}>'. +iteratorZip.ts(112,7): error TS2322: Type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator | undefined; readonly c?: Iterable | undefined; }, never, {}>[]' is not assignable to type '{ a: number; c: boolean; }[]'. + Type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator | undefined; readonly c?: Iterable | undefined; }, never, {}>' is not assignable to type '{ a: number; c: boolean; }'. + Types of property 'c' are incompatible. + Type 'boolean | undefined' is not assignable to type 'boolean'. + Type 'undefined' is not assignable to type 'boolean'. +iteratorZip.ts(132,14): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type 'undefined[]' is not assignable to parameter of type 'Iterable> & object'. + Type 'undefined[]' is not assignable to type 'Iterable>'. + The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. + Type 'IteratorResult' is not assignable to type 'IteratorResult, any>'. + Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>'. + Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>'. + Type 'undefined' is not assignable to type 'IteratorInput'. +iteratorZip.ts(150,7): error TS2322: Type '[number, ...(number | undefined)[]][]' is not assignable to type 'number[][]'. + Type '[number, ...(number | undefined)[]]' is not assignable to type 'number[]'. + Type 'number | undefined' is not assignable to type 'number'. + Type 'undefined' is not assignable to type 'number'. +iteratorZip.ts(155,7): error TS2322: Type 'IteratorZipResult<{ [x: string]: Iterable; } & {}, undefined, {}>[]' is not assignable to type 'Record[]'. + Type 'IteratorZipResult<{ [x: string]: Iterable; } & {}, undefined, {}>' is not assignable to type 'Record'. + 'string' index signatures are incompatible. + Type 'number | undefined' is not assignable to type 'number'. + Type 'undefined' is not assignable to type 'number'. +iteratorZip.ts(160,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record>[]' is not assignable to type '{ a: number; b: number; }[]'. + Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record>' is not assignable to type '{ a: number; b: number; }'. + Types of property 'a' are incompatible. + Type 'number | undefined' is not assignable to type 'number'. + Type 'undefined' is not assignable to type 'number'. +iteratorZip.ts(169,7): error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. + Type '[number, string | undefined]' is not assignable to type '[number, string]'. + Type at position 1 in source is not compatible with type at position 1 in target. + Type 'string | undefined' is not assignable to type 'string'. + Type 'undefined' is not assignable to type 'string'. +iteratorZip.ts(172,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; }>[]' is not assignable to type '{ a: number; b: string; }[]'. + Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; b: string; }'. + Types of property 'b' are incompatible. + Type 'string | undefined' is not assignable to type 'string'. + Type 'undefined' is not assignable to type 'string'. +iteratorZip.ts(178,7): error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. + Type '[number, string | undefined]' is not assignable to type '[number, string]'. + Type at position 1 in source is not compatible with type at position 1 in target. + Type 'string | undefined' is not assignable to type 'string'. + Type 'undefined' is not assignable to type 'string'. +iteratorZip.ts(182,7): error TS2322: Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>[]' is not assignable to type 'number[][]'. + Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>' is not assignable to type 'number[]'. + Type '[number, number | undefined]' is not assignable to type 'number[]'. + Type 'number | undefined' is not assignable to type 'number'. + Type 'undefined' is not assignable to type 'number'. +iteratorZip.ts(185,7): error TS2322: Type '(IteratorZipResult<{ a: Iterable; } & {}, undefined, { a: number; }> | IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>)[]' is not assignable to type '({ a: number; } | { b: string; })[]'. + Type 'IteratorZipResult<{ a: Iterable; } & {}, undefined, { a: number; }> | IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; } | { b: string; }'. + Type 'IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; } | { b: string; }'. + Type 'IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ b: string; }'. + Types of property 'b' are incompatible. + Type 'string | undefined' is not assignable to type 'string'. + Type 'undefined' is not assignable to type 'string'. +iteratorZip.ts(189,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; } | { b: string; }>[]' is not assignable to type '{ a: number; b: string; }[]'. + Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; } | { b: string; }>' is not assignable to type '{ a: number; b: string; }'. + Types of property 'a' are incompatible. + Type 'number | undefined' is not assignable to type 'number'. + Type 'undefined' is not assignable to type 'number'. +iteratorZip.ts(192,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, { a: undefined; b: number; }>[]' is not assignable to type '{ a: number; b: number; }[]'. + Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, { a: undefined; b: number; }>' is not assignable to type '{ a: number; b: number; }'. + Types of property 'a' are incompatible. + Type 'number | undefined' is not assignable to type 'number'. + Type 'undefined' is not assignable to type 'number'. +iteratorZip.ts(196,7): error TS2322: Type 'IteratorZipResult<{ [x: `a${string}`]: Iterable; } & {}, undefined, {}>[]' is not assignable to type '{ [x: `a${string}`]: number; }[]'. + Type 'IteratorZipResult<{ [x: `a${string}`]: Iterable; } & {}, undefined, {}>' is not assignable to type '{ [x: `a${string}`]: number; }'. + '`a${string}`' index signatures are incompatible. + Type 'number | undefined' is not assignable to type 'number'. + Type 'undefined' is not assignable to type 'number'. +iteratorZip.ts(204,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record & { a: number; }>[]' is not assignable to type '{ a: number; b: number; }[]'. + Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record & { a: number; }>' is not assignable to type '{ a: number; b: number; }'. + Types of property 'b' are incompatible. + Type 'number | undefined' is not assignable to type 'number'. + Type 'undefined' is not assignable to type 'number'. +iteratorZip.ts(209,7): error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. + Type '[number, string | undefined]' is not assignable to type '[number, string]'. + Type at position 1 in source is not compatible with type at position 1 in target. + Type 'string | undefined' is not assignable to type 'string'. + Type 'undefined' is not assignable to type 'string'. +iteratorZip.ts(248,7): error TS2322: Type 'unknown' is not assignable to type 'string'. +iteratorZip.ts(249,7): error TS2322: Type 'unknown' is not assignable to type 'string'. +iteratorZip.ts(258,19): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type '0' is not assignable to parameter of type 'never'. +iteratorZip.ts(259,19): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type 'null' is not assignable to parameter of type 'never'. +iteratorZip.ts(260,31): error TS2769: No overload matches this call. + The last overload gave the following error. + Type '"invalid"' is not assignable to type '"longest" | "shortest" | "strict" | undefined'. +iteratorZip.ts(261,49): error TS2769: No overload matches this call. + The last overload gave the following error. + Object literal may only specify known properties, and 'padding' does not exist in type 'IteratorZipShortestOptions'. +iteratorZip.ts(262,48): error TS2769: No overload matches this call. + The last overload gave the following error. + Type 'number' is not assignable to type 'object'. +iteratorZip.ts(263,19): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type '{ values: number[]; }' is not assignable to parameter of type 'never'. + + +==== iteratorZip.ts (36 errors) ==== + declare const key: unique symbol; + + const tuples: [number, string][] = Iterator.zip([ + [1, 2], + new Set(["a", "b"]), + ] as const).toArray(); + + tuples[0][0] = 2; + + const shortestTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray(); + const strictTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray(); + const longestTuplesWithPadding: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray(); + const longestTuplesWithoutPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray(); + const longestTuplesWithPartialPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray(); + + declare const maybeLongestOptions: { mode: "shortest"; } | { mode: "longest"; }; + const maybeLongestTuples: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray(); + + const empty: never[] = Iterator.zip([]).toArray(); + const emptyLongest: never[] = Iterator.zip([], { mode: "longest" }).toArray(); + + declare const iterables: Iterable>; + const arrays: number[][] = Iterator.zip(iterables).toArray(); + const longestArrays: (number | undefined)[][] = Iterator.zip(iterables, { mode: "longest" }).toArray(); + const maybeLongestArrays: (number | undefined)[][] = Iterator.zip(iterables, maybeLongestOptions).toArray(); + + declare const iterableArray: Iterable[]; + const longestArrayWithPadding: (number | undefined)[][] = Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray(); + + const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ + a: [1, 2], + b: new Set(["a", "b"]), + [key]: [true, false], + } as const).toArray(); + + objects[0].a = 2; + + const longestObjectsWithPadding: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { + mode: "longest", + padding: { a: 1, b: "a" }, + }).toArray(); + + const longestObjectsWithoutPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { + mode: "longest", + }).toArray(); + + const longestObjectsWithPartialPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { + mode: "longest", + padding: { b: "a" }, + }).toArray(); + + const maybeLongestObjects: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray(); + + interface Inputs { + a: Iterable; + b: Iterator; + } + + declare const inputs: Inputs; + const rows: { a: number; b: string; }[] = Iterator.zipKeyed(inputs).toArray(); + + Iterator.zip([[1]], { mode: "invalid" }); + ~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Type '"invalid"' is not assignable to type '"longest" | "shortest" | "strict" | undefined'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + + Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }); + ~~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Type 'true[]' is not assignable to type 'Iterable<"a" | 1 | undefined> & object'. +!!! error TS2769: Type 'true[]' is not assignable to type 'Iterable<"a" | 1 | undefined>'. +!!! error TS2769: The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. +!!! error TS2769: Type 'IteratorResult' is not assignable to type 'IteratorResult<"a" | 1 | undefined, any>'. +!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorResult<"a" | 1 | undefined, any>'. +!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult<"a" | 1 | undefined>'. +!!! error TS2769: Type 'true' is not assignable to type '"a" | 1 | undefined'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + + Iterator.zip([[1]], { mode: "shortest", padding: [1] }); + ~~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Object literal may only specify known properties, and 'padding' does not exist in type 'IteratorZipShortestOptions'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + + Iterator.zip(0); + ~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type 'number' is not assignable to parameter of type 'Iterable> & object'. +!!! error TS2769: Type 'number' is not assignable to type 'Iterable>'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + + Iterator.zipKeyed({ a: 0 }); + + const emptyKeyed: never[] = Iterator.zipKeyed({}).toArray(); + const emptyKeyedLongest: never[] = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); + + declare const unionInputs: { a: Iterable; } | { b: Iterator; }; + const unionRows: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(unionInputs).toArray(); + + // Inputs + + Iterator.zip("ab"); + ~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type 'string' is not assignable to parameter of type 'Iterable> & object'. +!!! error TS2769: Type 'string' is not assignable to type 'Iterable>'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + Iterator.zip(["ab"]); + ~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type 'string[]' is not assignable to parameter of type 'Iterable> & object'. +!!! error TS2769: Type 'string[]' is not assignable to type 'Iterable>'. +!!! error TS2769: The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. +!!! error TS2769: Type 'IteratorResult' is not assignable to type 'IteratorResult, any>'. +!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>'. +!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>'. +!!! error TS2769: Type 'string' is not assignable to type 'IteratorInput'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + Iterator.zip(new Set(["ab"])); + ~~~~~~~~~~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type 'Set' is not assignable to parameter of type 'Iterable> & object'. +!!! error TS2769: Type 'Set' is not assignable to type 'Iterable>'. +!!! error TS2769: The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. +!!! error TS2769: Type 'IteratorResult' is not assignable to type 'IteratorResult, any>'. +!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>'. +!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>'. +!!! error TS2769: Type 'string' is not assignable to type 'IteratorInput'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + Iterator.zipKeyed("ab"); + ~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type '"ab"' is not assignable to parameter of type 'never'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + Iterator.zipKeyed({ a: "ab" }); + Iterator.zip([], { mode: "longest", padding: "ab" }); + ~~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Type 'string' is not assignable to type 'Iterable & object'. +!!! error TS2769: Type 'string' is not assignable to type 'Iterable'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); + ~~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Type 'string' is not assignable to type 'Iterable & object'. +!!! error TS2769: Type 'string' is not assignable to type 'object'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); + ~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type '{}' is not assignable to parameter of type 'never'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + + const a: [string][] = Iterator.zip([new String("ab")]).toArray(); + const b: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); + const c: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); + + const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); + const e: { a: number; }[] = d; + d[0].b; + ~ +!!! error TS2339: Property 'b' does not exist on type 'IteratorZipResult<{ a: number[]; } & {}, never, {}>'. + const f: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); + const g: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); + + interface I { + readonly a: Iterable; + readonly b?: Iterator; + readonly c: Iterable | undefined; + readonly d?: undefined; + } + declare const h: I; + const i = Iterator.zipKeyed(h).toArray(); + const j: { a: number; b?: string; c?: boolean; }[] = i; + i[0].a = 2; + i[0].b = "a"; + i[0].c = true; + i[0].d; + ~ +!!! error TS2339: Property 'd' does not exist on type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator | undefined; readonly c?: Iterable | undefined; }, never, {}>'. + const k: { a: number; c: boolean; }[] = i; + ~ +!!! error TS2322: Type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator | undefined; readonly c?: Iterable | undefined; }, never, {}>[]' is not assignable to type '{ a: number; c: boolean; }[]'. +!!! error TS2322: Type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator | undefined; readonly c?: Iterable | undefined; }, never, {}>' is not assignable to type '{ a: number; c: boolean; }'. +!!! error TS2322: Types of property 'c' are incompatible. +!!! error TS2322: Type 'boolean | undefined' is not assignable to type 'boolean'. +!!! error TS2322: Type 'undefined' is not assignable to type 'boolean'. + const l: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); + + declare const m: { a: Iterable; } | { b: Iterator; }; + const n: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(m).toArray(); + declare const o: { a: Iterable; } | { b: number; }; + Iterator.zipKeyed(o); + Iterator.zipKeyed(o, { mode: "longest" }); + Iterator.zipKeyed(o, { mode: "longest", padding: {} }); + declare const p: { a?: Iterable; } | { b: string; }; + Iterator.zipKeyed(p); + declare const q: { a: Iterable; } | { b: undefined; }; + const r: { a: number; }[] = Iterator.zipKeyed(q).toArray(); + + declare const s: unique symbol; + declare const t: { a: Iterable; [s]?: Iterable; }; + const u: { a: number; [s]?: string; }[] = Iterator.zipKeyed(t).toArray(); + + Iterator.zipKeyed({ a: [1], b: null }); + Iterator.zipKeyed({ a: [1], b: false }); + Iterator.zip([undefined]); + ~~~~~~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type 'undefined[]' is not assignable to parameter of type 'Iterable> & object'. +!!! error TS2769: Type 'undefined[]' is not assignable to type 'Iterable>'. +!!! error TS2769: The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. +!!! error TS2769: Type 'IteratorResult' is not assignable to type 'IteratorResult, any>'. +!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>'. +!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>'. +!!! error TS2769: Type 'undefined' is not assignable to type 'IteratorInput'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + + declare const v: { a?: undefined; }; + const w: never[] = Iterator.zipKeyed(v).toArray(); + const x: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); + const y: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); + + function f1(a: Iterable) { + const b: { a: T; }[] = Iterator.zipKeyed({ a }).toArray(); + const c: [T][] = Iterator.zip([a]).toArray(); + return { b, c }; + } + + // Padding + + const paddingA: [Iterable, ...Iterable[]] = [[1, 2], [3]]; + const paddingB = Iterator.zip(paddingA, { mode: "longest", padding: [0] }).toArray(); + const paddingC: (number | undefined)[][] = paddingB; + const paddingD: number[][] = paddingB; + ~~~~~~~~ +!!! error TS2322: Type '[number, ...(number | undefined)[]][]' is not assignable to type 'number[][]'. +!!! error TS2322: Type '[number, ...(number | undefined)[]]' is not assignable to type 'number[]'. +!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'undefined' is not assignable to type 'number'. + + const paddingE: Record> = { a: [1], b: [2, 3] }; + const paddingF = Iterator.zipKeyed(paddingE, { mode: "longest", padding: {} }).toArray(); + const paddingG: Record[] = paddingF; + const paddingH: Record[] = paddingF; + ~~~~~~~~ +!!! error TS2322: Type 'IteratorZipResult<{ [x: string]: Iterable; } & {}, undefined, {}>[]' is not assignable to type 'Record[]'. +!!! error TS2322: Type 'IteratorZipResult<{ [x: string]: Iterable; } & {}, undefined, {}>' is not assignable to type 'Record'. +!!! error TS2322: 'string' index signatures are incompatible. +!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'undefined' is not assignable to type 'number'. + + declare const paddingI: Record; + const paddingJ = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: paddingI }).toArray(); + const paddingK: { a: number | undefined; b: number | undefined; }[] = paddingJ; + const paddingL: { a: number; b: number; }[] = paddingJ; + ~~~~~~~~ +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record>[]' is not assignable to type '{ a: number; b: number; }[]'. +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record>' is not assignable to type '{ a: number; b: number; }'. +!!! error TS2322: Types of property 'a' are incompatible. +!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'undefined' is not assignable to type 'number'. + + const paddingM = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); + const paddingN: [number, string][] = paddingM; + const paddingO = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); + const paddingP: { a: number; b: string; }[] = paddingO; + + const paddingQ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); + const paddingR: [number | undefined, string | undefined][] = paddingQ; + const paddingS: [number, string][] = paddingQ; + ~~~~~~~~ +!!! error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. +!!! error TS2322: Type '[number, string | undefined]' is not assignable to type '[number, string]'. +!!! error TS2322: Type at position 1 in source is not compatible with type at position 1 in target. +!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. +!!! error TS2322: Type 'undefined' is not assignable to type 'string'. + const paddingT = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); + const paddingU: { a: number | undefined; b: string | undefined; }[] = paddingT; + const paddingV: { a: number; b: string; }[] = paddingT; + ~~~~~~~~ +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; }>[]' is not assignable to type '{ a: number; b: string; }[]'. +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; b: string; }'. +!!! error TS2322: Types of property 'b' are incompatible. +!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. +!!! error TS2322: Type 'undefined' is not assignable to type 'string'. + + declare const paddingW: readonly [number, string]; + const paddingX: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingW }).toArray(); + declare const paddingY: [number, string?]; + const paddingZ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY }).toArray(); + const paddingA1: [number, string][] = paddingZ; + ~~~~~~~~~ +!!! error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. +!!! error TS2322: Type '[number, string | undefined]' is not assignable to type '[number, string]'. +!!! error TS2322: Type at position 1 in source is not compatible with type at position 1 in target. +!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. +!!! error TS2322: Type 'undefined' is not assignable to type 'string'. + + declare const paddingB1: [Iterable] | [Iterable, Iterable]; + const paddingC1 = Iterator.zip(paddingB1, { mode: "longest", padding: [0] }).toArray(); + const paddingD1: number[][] = paddingC1; + ~~~~~~~~~ +!!! error TS2322: Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>[]' is not assignable to type 'number[][]'. +!!! error TS2322: Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>' is not assignable to type 'number[]'. +!!! error TS2322: Type '[number, number | undefined]' is not assignable to type 'number[]'. +!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'undefined' is not assignable to type 'number'. + declare const paddingE1: { a: Iterable; } | { b: Iterable; }; + const paddingF1 = Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: 0 } }).toArray(); + const paddingG1: ({ a: number; } | { b: string; })[] = paddingF1; + ~~~~~~~~~ +!!! error TS2322: Type '(IteratorZipResult<{ a: Iterable; } & {}, undefined, { a: number; }> | IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>)[]' is not assignable to type '({ a: number; } | { b: string; })[]'. +!!! error TS2322: Type 'IteratorZipResult<{ a: Iterable; } & {}, undefined, { a: number; }> | IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; } | { b: string; }'. +!!! error TS2322: Type 'IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; } | { b: string; }'. +!!! error TS2322: Type 'IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ b: string; }'. +!!! error TS2322: Types of property 'b' are incompatible. +!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. +!!! error TS2322: Type 'undefined' is not assignable to type 'string'. + + declare const paddingH1: { a: number; } | { b: string; }; + const paddingI1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: paddingH1 }).toArray(); + const paddingJ1: { a: number; b: string; }[] = paddingI1; + ~~~~~~~~~ +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; } | { b: string; }>[]' is not assignable to type '{ a: number; b: string; }[]'. +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; } | { b: string; }>' is not assignable to type '{ a: number; b: string; }'. +!!! error TS2322: Types of property 'a' are incompatible. +!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'undefined' is not assignable to type 'number'. + + const paddingK1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); + const paddingL1: { a: number; b: number; }[] = paddingK1; + ~~~~~~~~~ +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, { a: undefined; b: number; }>[]' is not assignable to type '{ a: number; b: number; }[]'. +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, { a: undefined; b: number; }>' is not assignable to type '{ a: number; b: number; }'. +!!! error TS2322: Types of property 'a' are incompatible. +!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'undefined' is not assignable to type 'number'. + + declare const paddingM1: { [K in `a${string}`]: Iterable; }; + const paddingN1 = Iterator.zipKeyed(paddingM1, { mode: "longest", padding: {} }).toArray(); + const paddingO1: { [K in `a${string}`]: number; }[] = paddingN1; + ~~~~~~~~~ +!!! error TS2322: Type 'IteratorZipResult<{ [x: `a${string}`]: Iterable; } & {}, undefined, {}>[]' is not assignable to type '{ [x: `a${string}`]: number; }[]'. +!!! error TS2322: Type 'IteratorZipResult<{ [x: `a${string}`]: Iterable; } & {}, undefined, {}>' is not assignable to type '{ [x: `a${string}`]: number; }'. +!!! error TS2322: '`a${string}`' index signatures are incompatible. +!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'undefined' is not assignable to type 'number'. + + declare const paddingP1: unique symbol; + const paddingQ1: { [paddingP1]: number; }[] = Iterator.zipKeyed({ [paddingP1]: [1] }, { mode: "longest", padding: { [paddingP1]: 0 } }).toArray(); + + declare const paddingR1: Record & { a: number; }; + const paddingS1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: paddingR1 }).toArray(); + const paddingT1: { a: number; b: number | undefined; }[] = paddingS1; + const paddingU1: { a: number; b: number; }[] = paddingS1; + ~~~~~~~~~ +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record & { a: number; }>[]' is not assignable to type '{ a: number; b: number; }[]'. +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record & { a: number; }>' is not assignable to type '{ a: number; b: number; }'. +!!! error TS2322: Types of property 'b' are incompatible. +!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'undefined' is not assignable to type 'number'. + + declare const paddingV1: [number] | [number, string]; + const paddingW1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingV1 }).toArray(); + const paddingX1: [number, string | undefined][] = paddingW1; + const paddingY1: [number, string][] = paddingW1; + ~~~~~~~~~ +!!! error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. +!!! error TS2322: Type '[number, string | undefined]' is not assignable to type '[number, string]'. +!!! error TS2322: Type at position 1 in source is not compatible with type at position 1 in target. +!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. +!!! error TS2322: Type 'undefined' is not assignable to type 'string'. + + const paddingZ1: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); + const paddingA2: { a: number | undefined; b: number; }[] = paddingK1; + + // Own properties + + class InputsWithPrototypeMembers { + values = [1, 2]; + + get label() { + return "inputs"; + } + + describe() { + return this.label; + } + } + + const instance = new InputsWithPrototypeMembers(); + const inherited = Iterator.zipKeyed(instance).toArray(); + const inheritedStrict = Iterator.zipKeyed(instance, { mode: "strict" }).toArray(); + const inheritedLongest = Iterator.zipKeyed(instance, { mode: "longest" }).toArray(); + const inheritedPadded = Iterator.zipKeyed(instance, { mode: "longest", padding: { values: 0 } }).toArray(); + + const hiddenInputs = { values: [1, 2], label: "inputs" }; + Object.defineProperty(hiddenInputs, "label", { enumerable: false }); + const nonEnumerable = Iterator.zipKeyed(hiddenInputs).toArray(); + const nonEnumerablePadded = Iterator.zipKeyed(hiddenInputs, { mode: "longest", padding: { values: 0 } }).toArray(); + + // The same static shape can have an enumerable non-iterator property instead. + // Such inputs are accepted by the fallback and checked at runtime. + const enumerableInputs = { values: [1, 2], label: "inputs" }; + const enumerable = Iterator.zipKeyed(enumerableInputs).toArray(); + + // The array's length and methods are not enumerable own properties. + const arrayInputs = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); + + // The fallback must not claim that ignored properties exist on yielded objects. + const inheritedLabel: string = inherited[0].label; + ~~~~~~~~~~~~~~ +!!! error TS2322: Type 'unknown' is not assignable to type 'string'. + const nonEnumerableLabel: string = nonEnumerable[0].label; + ~~~~~~~~~~~~~~~~~~ +!!! error TS2322: Type 'unknown' is not assignable to type 'string'. + + // Precise record inference still handles symbol keys and padding. + declare const ownKey: unique symbol; + const precise: { values: number; [ownKey]: string; }[] = Iterator.zipKeyed({ values: [1], [ownKey]: ["a"] }).toArray(); + const preciseLongest: { values: number | undefined; }[] = Iterator.zipKeyed({ values: [1] }, { mode: "longest" }).toArray(); + const precisePadded: { values: number; }[] = Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: 0 } }).toArray(); + const emptyOwnProperties: never[] = Iterator.zipKeyed({}).toArray(); + + Iterator.zipKeyed(0); + ~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type '0' is not assignable to parameter of type 'never'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + Iterator.zipKeyed(null); + ~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type 'null' is not assignable to parameter of type 'never'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + Iterator.zipKeyed(instance, { mode: "invalid" }); + ~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Type '"invalid"' is not assignable to type '"longest" | "shortest" | "strict" | undefined'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + Iterator.zipKeyed(instance, { mode: "shortest", padding: {} }); + ~~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Object literal may only specify known properties, and 'padding' does not exist in type 'IteratorZipShortestOptions'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + Iterator.zipKeyed(instance, { mode: "longest", padding: 0 }); + ~~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Type 'number' is not assignable to type 'object'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: "invalid" } }); + ~~~~~~~~~~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type '{ values: number[]; }' is not assignable to parameter of type 'never'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).js b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).js new file mode 100644 index 0000000000000..f0303738a402c --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).js @@ -0,0 +1,762 @@ +//// [tests/cases/compiler/iteratorZip.ts] //// + +//// [iteratorZip.ts] +declare const key: unique symbol; + +const tuples: [number, string][] = Iterator.zip([ + [1, 2], + new Set(["a", "b"]), +] as const).toArray(); + +tuples[0][0] = 2; + +const shortestTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray(); +const strictTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray(); +const longestTuplesWithPadding: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray(); +const longestTuplesWithoutPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray(); +const longestTuplesWithPartialPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray(); + +declare const maybeLongestOptions: { mode: "shortest"; } | { mode: "longest"; }; +const maybeLongestTuples: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray(); + +const empty: never[] = Iterator.zip([]).toArray(); +const emptyLongest: never[] = Iterator.zip([], { mode: "longest" }).toArray(); + +declare const iterables: Iterable>; +const arrays: number[][] = Iterator.zip(iterables).toArray(); +const longestArrays: (number | undefined)[][] = Iterator.zip(iterables, { mode: "longest" }).toArray(); +const maybeLongestArrays: (number | undefined)[][] = Iterator.zip(iterables, maybeLongestOptions).toArray(); + +declare const iterableArray: Iterable[]; +const longestArrayWithPadding: (number | undefined)[][] = Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray(); + +const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ + a: [1, 2], + b: new Set(["a", "b"]), + [key]: [true, false], +} as const).toArray(); + +objects[0].a = 2; + +const longestObjectsWithPadding: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { + mode: "longest", + padding: { a: 1, b: "a" }, +}).toArray(); + +const longestObjectsWithoutPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { + mode: "longest", +}).toArray(); + +const longestObjectsWithPartialPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { + mode: "longest", + padding: { b: "a" }, +}).toArray(); + +const maybeLongestObjects: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray(); + +interface Inputs { + a: Iterable; + b: Iterator; +} + +declare const inputs: Inputs; +const rows: { a: number; b: string; }[] = Iterator.zipKeyed(inputs).toArray(); + +Iterator.zip([[1]], { mode: "invalid" }); + +Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }); + +Iterator.zip([[1]], { mode: "shortest", padding: [1] }); + +Iterator.zip(0); + +Iterator.zipKeyed({ a: 0 }); + +const emptyKeyed: never[] = Iterator.zipKeyed({}).toArray(); +const emptyKeyedLongest: never[] = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); + +declare const unionInputs: { a: Iterable; } | { b: Iterator; }; +const unionRows: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(unionInputs).toArray(); + +// Inputs + +Iterator.zip("ab"); +Iterator.zip(["ab"]); +Iterator.zip(new Set(["ab"])); +Iterator.zipKeyed("ab"); +Iterator.zipKeyed({ a: "ab" }); +Iterator.zip([], { mode: "longest", padding: "ab" }); +Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); +Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); + +const a: [string][] = Iterator.zip([new String("ab")]).toArray(); +const b: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); +const c: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); + +const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); +const e: { a: number; }[] = d; +d[0].b; +const f: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); +const g: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); + +interface I { + readonly a: Iterable; + readonly b?: Iterator; + readonly c: Iterable | undefined; + readonly d?: undefined; +} +declare const h: I; +const i = Iterator.zipKeyed(h).toArray(); +const j: { a: number; b?: string; c?: boolean; }[] = i; +i[0].a = 2; +i[0].b = "a"; +i[0].c = true; +i[0].d; +const k: { a: number; c: boolean; }[] = i; +const l: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); + +declare const m: { a: Iterable; } | { b: Iterator; }; +const n: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(m).toArray(); +declare const o: { a: Iterable; } | { b: number; }; +Iterator.zipKeyed(o); +Iterator.zipKeyed(o, { mode: "longest" }); +Iterator.zipKeyed(o, { mode: "longest", padding: {} }); +declare const p: { a?: Iterable; } | { b: string; }; +Iterator.zipKeyed(p); +declare const q: { a: Iterable; } | { b: undefined; }; +const r: { a: number; }[] = Iterator.zipKeyed(q).toArray(); + +declare const s: unique symbol; +declare const t: { a: Iterable; [s]?: Iterable; }; +const u: { a: number; [s]?: string; }[] = Iterator.zipKeyed(t).toArray(); + +Iterator.zipKeyed({ a: [1], b: null }); +Iterator.zipKeyed({ a: [1], b: false }); +Iterator.zip([undefined]); + +declare const v: { a?: undefined; }; +const w: never[] = Iterator.zipKeyed(v).toArray(); +const x: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); +const y: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); + +function f1(a: Iterable) { + const b: { a: T; }[] = Iterator.zipKeyed({ a }).toArray(); + const c: [T][] = Iterator.zip([a]).toArray(); + return { b, c }; +} + +// Padding + +const paddingA: [Iterable, ...Iterable[]] = [[1, 2], [3]]; +const paddingB = Iterator.zip(paddingA, { mode: "longest", padding: [0] }).toArray(); +const paddingC: (number | undefined)[][] = paddingB; +const paddingD: number[][] = paddingB; + +const paddingE: Record> = { a: [1], b: [2, 3] }; +const paddingF = Iterator.zipKeyed(paddingE, { mode: "longest", padding: {} }).toArray(); +const paddingG: Record[] = paddingF; +const paddingH: Record[] = paddingF; + +declare const paddingI: Record; +const paddingJ = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: paddingI }).toArray(); +const paddingK: { a: number | undefined; b: number | undefined; }[] = paddingJ; +const paddingL: { a: number; b: number; }[] = paddingJ; + +const paddingM = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); +const paddingN: [number, string][] = paddingM; +const paddingO = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); +const paddingP: { a: number; b: string; }[] = paddingO; + +const paddingQ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); +const paddingR: [number | undefined, string | undefined][] = paddingQ; +const paddingS: [number, string][] = paddingQ; +const paddingT = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); +const paddingU: { a: number | undefined; b: string | undefined; }[] = paddingT; +const paddingV: { a: number; b: string; }[] = paddingT; + +declare const paddingW: readonly [number, string]; +const paddingX: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingW }).toArray(); +declare const paddingY: [number, string?]; +const paddingZ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY }).toArray(); +const paddingA1: [number, string][] = paddingZ; + +declare const paddingB1: [Iterable] | [Iterable, Iterable]; +const paddingC1 = Iterator.zip(paddingB1, { mode: "longest", padding: [0] }).toArray(); +const paddingD1: number[][] = paddingC1; +declare const paddingE1: { a: Iterable; } | { b: Iterable; }; +const paddingF1 = Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: 0 } }).toArray(); +const paddingG1: ({ a: number; } | { b: string; })[] = paddingF1; + +declare const paddingH1: { a: number; } | { b: string; }; +const paddingI1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: paddingH1 }).toArray(); +const paddingJ1: { a: number; b: string; }[] = paddingI1; + +const paddingK1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); +const paddingL1: { a: number; b: number; }[] = paddingK1; + +declare const paddingM1: { [K in `a${string}`]: Iterable; }; +const paddingN1 = Iterator.zipKeyed(paddingM1, { mode: "longest", padding: {} }).toArray(); +const paddingO1: { [K in `a${string}`]: number; }[] = paddingN1; + +declare const paddingP1: unique symbol; +const paddingQ1: { [paddingP1]: number; }[] = Iterator.zipKeyed({ [paddingP1]: [1] }, { mode: "longest", padding: { [paddingP1]: 0 } }).toArray(); + +declare const paddingR1: Record & { a: number; }; +const paddingS1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: paddingR1 }).toArray(); +const paddingT1: { a: number; b: number | undefined; }[] = paddingS1; +const paddingU1: { a: number; b: number; }[] = paddingS1; + +declare const paddingV1: [number] | [number, string]; +const paddingW1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingV1 }).toArray(); +const paddingX1: [number, string | undefined][] = paddingW1; +const paddingY1: [number, string][] = paddingW1; + +const paddingZ1: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); +const paddingA2: { a: number | undefined; b: number; }[] = paddingK1; + +// Own properties + +class InputsWithPrototypeMembers { + values = [1, 2]; + + get label() { + return "inputs"; + } + + describe() { + return this.label; + } +} + +const instance = new InputsWithPrototypeMembers(); +const inherited = Iterator.zipKeyed(instance).toArray(); +const inheritedStrict = Iterator.zipKeyed(instance, { mode: "strict" }).toArray(); +const inheritedLongest = Iterator.zipKeyed(instance, { mode: "longest" }).toArray(); +const inheritedPadded = Iterator.zipKeyed(instance, { mode: "longest", padding: { values: 0 } }).toArray(); + +const hiddenInputs = { values: [1, 2], label: "inputs" }; +Object.defineProperty(hiddenInputs, "label", { enumerable: false }); +const nonEnumerable = Iterator.zipKeyed(hiddenInputs).toArray(); +const nonEnumerablePadded = Iterator.zipKeyed(hiddenInputs, { mode: "longest", padding: { values: 0 } }).toArray(); + +// The same static shape can have an enumerable non-iterator property instead. +// Such inputs are accepted by the fallback and checked at runtime. +const enumerableInputs = { values: [1, 2], label: "inputs" }; +const enumerable = Iterator.zipKeyed(enumerableInputs).toArray(); + +// The array's length and methods are not enumerable own properties. +const arrayInputs = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); + +// The fallback must not claim that ignored properties exist on yielded objects. +const inheritedLabel: string = inherited[0].label; +const nonEnumerableLabel: string = nonEnumerable[0].label; + +// Precise record inference still handles symbol keys and padding. +declare const ownKey: unique symbol; +const precise: { values: number; [ownKey]: string; }[] = Iterator.zipKeyed({ values: [1], [ownKey]: ["a"] }).toArray(); +const preciseLongest: { values: number | undefined; }[] = Iterator.zipKeyed({ values: [1] }, { mode: "longest" }).toArray(); +const precisePadded: { values: number; }[] = Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: 0 } }).toArray(); +const emptyOwnProperties: never[] = Iterator.zipKeyed({}).toArray(); + +Iterator.zipKeyed(0); +Iterator.zipKeyed(null); +Iterator.zipKeyed(instance, { mode: "invalid" }); +Iterator.zipKeyed(instance, { mode: "shortest", padding: {} }); +Iterator.zipKeyed(instance, { mode: "longest", padding: 0 }); +Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: "invalid" } }); + + +//// [iteratorZip.js] +"use strict"; +const tuples = Iterator.zip([ + [1, 2], + new Set(["a", "b"]), +]).toArray(); +tuples[0][0] = 2; +const shortestTuples = Iterator.zip([[1], ["a"]], { mode: "shortest" }).toArray(); +const strictTuples = Iterator.zip([[1], ["a"]], { mode: "strict" }).toArray(); +const longestTuplesWithPadding = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [1, "a"] }).toArray(); +const longestTuplesWithoutPadding = Iterator.zip([[1], ["a"]], { mode: "longest" }).toArray(); +const longestTuplesWithPartialPadding = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [1] }).toArray(); +const maybeLongestTuples = Iterator.zip([[1], ["a"]], maybeLongestOptions).toArray(); +const empty = Iterator.zip([]).toArray(); +const emptyLongest = Iterator.zip([], { mode: "longest" }).toArray(); +const arrays = Iterator.zip(iterables).toArray(); +const longestArrays = Iterator.zip(iterables, { mode: "longest" }).toArray(); +const maybeLongestArrays = Iterator.zip(iterables, maybeLongestOptions).toArray(); +const longestArrayWithPadding = Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray(); +const objects = Iterator.zipKeyed({ + a: [1, 2], + b: new Set(["a", "b"]), + [key]: [true, false], +}).toArray(); +objects[0].a = 2; +const longestObjectsWithPadding = Iterator.zipKeyed({ a: [1], b: ["a"] }, { + mode: "longest", + padding: { a: 1, b: "a" }, +}).toArray(); +const longestObjectsWithoutPadding = Iterator.zipKeyed({ a: [1], b: ["a"] }, { + mode: "longest", +}).toArray(); +const longestObjectsWithPartialPadding = Iterator.zipKeyed({ a: [1], b: ["a"] }, { + mode: "longest", + padding: { b: "a" }, +}).toArray(); +const maybeLongestObjects = Iterator.zipKeyed({ a: [1], b: ["a"] }, maybeLongestOptions).toArray(); +const rows = Iterator.zipKeyed(inputs).toArray(); +Iterator.zip([[1]], { mode: "invalid" }); +Iterator.zip([[1], ["a"]], { mode: "longest", padding: [true] }); +Iterator.zip([[1]], { mode: "shortest", padding: [1] }); +Iterator.zip(0); +Iterator.zipKeyed({ a: 0 }); +const emptyKeyed = Iterator.zipKeyed({}).toArray(); +const emptyKeyedLongest = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); +const unionRows = Iterator.zipKeyed(unionInputs).toArray(); +// Inputs +Iterator.zip("ab"); +Iterator.zip(["ab"]); +Iterator.zip(new Set(["ab"])); +Iterator.zipKeyed("ab"); +Iterator.zipKeyed({ a: "ab" }); +Iterator.zip([], { mode: "longest", padding: "ab" }); +Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); +Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); +const a = Iterator.zip([new String("ab")]).toArray(); +const b = Iterator.zipKeyed({ a: new String("ab") }).toArray(); +const c = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); +const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); +const e = d; +d[0].b; +const f = Iterator.zipKeyed({ a: undefined }).toArray(); +const g = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); +const i = Iterator.zipKeyed(h).toArray(); +const j = i; +i[0].a = 2; +i[0].b = "a"; +i[0].c = true; +i[0].d; +const k = i; +const l = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); +const n = Iterator.zipKeyed(m).toArray(); +Iterator.zipKeyed(o); +Iterator.zipKeyed(o, { mode: "longest" }); +Iterator.zipKeyed(o, { mode: "longest", padding: {} }); +Iterator.zipKeyed(p); +const r = Iterator.zipKeyed(q).toArray(); +const u = Iterator.zipKeyed(t).toArray(); +Iterator.zipKeyed({ a: [1], b: null }); +Iterator.zipKeyed({ a: [1], b: false }); +Iterator.zip([undefined]); +const w = Iterator.zipKeyed(v).toArray(); +const x = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); +const y = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); +function f1(a) { + const b = Iterator.zipKeyed({ a }).toArray(); + const c = Iterator.zip([a]).toArray(); + return { b, c }; +} +// Padding +const paddingA = [[1, 2], [3]]; +const paddingB = Iterator.zip(paddingA, { mode: "longest", padding: [0] }).toArray(); +const paddingC = paddingB; +const paddingD = paddingB; +const paddingE = { a: [1], b: [2, 3] }; +const paddingF = Iterator.zipKeyed(paddingE, { mode: "longest", padding: {} }).toArray(); +const paddingG = paddingF; +const paddingH = paddingF; +const paddingJ = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: paddingI }).toArray(); +const paddingK = paddingJ; +const paddingL = paddingJ; +const paddingM = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); +const paddingN = paddingM; +const paddingO = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); +const paddingP = paddingO; +const paddingQ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); +const paddingR = paddingQ; +const paddingS = paddingQ; +const paddingT = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); +const paddingU = paddingT; +const paddingV = paddingT; +const paddingX = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingW }).toArray(); +const paddingZ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY }).toArray(); +const paddingA1 = paddingZ; +const paddingC1 = Iterator.zip(paddingB1, { mode: "longest", padding: [0] }).toArray(); +const paddingD1 = paddingC1; +const paddingF1 = Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: 0 } }).toArray(); +const paddingG1 = paddingF1; +const paddingI1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: paddingH1 }).toArray(); +const paddingJ1 = paddingI1; +const paddingK1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); +const paddingL1 = paddingK1; +const paddingN1 = Iterator.zipKeyed(paddingM1, { mode: "longest", padding: {} }).toArray(); +const paddingO1 = paddingN1; +const paddingQ1 = Iterator.zipKeyed({ [paddingP1]: [1] }, { mode: "longest", padding: { [paddingP1]: 0 } }).toArray(); +const paddingS1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: paddingR1 }).toArray(); +const paddingT1 = paddingS1; +const paddingU1 = paddingS1; +const paddingW1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingV1 }).toArray(); +const paddingX1 = paddingW1; +const paddingY1 = paddingW1; +const paddingZ1 = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); +const paddingA2 = paddingK1; +// Own properties +class InputsWithPrototypeMembers { + values = [1, 2]; + get label() { + return "inputs"; + } + describe() { + return this.label; + } +} +const instance = new InputsWithPrototypeMembers(); +const inherited = Iterator.zipKeyed(instance).toArray(); +const inheritedStrict = Iterator.zipKeyed(instance, { mode: "strict" }).toArray(); +const inheritedLongest = Iterator.zipKeyed(instance, { mode: "longest" }).toArray(); +const inheritedPadded = Iterator.zipKeyed(instance, { mode: "longest", padding: { values: 0 } }).toArray(); +const hiddenInputs = { values: [1, 2], label: "inputs" }; +Object.defineProperty(hiddenInputs, "label", { enumerable: false }); +const nonEnumerable = Iterator.zipKeyed(hiddenInputs).toArray(); +const nonEnumerablePadded = Iterator.zipKeyed(hiddenInputs, { mode: "longest", padding: { values: 0 } }).toArray(); +// The same static shape can have an enumerable non-iterator property instead. +// Such inputs are accepted by the fallback and checked at runtime. +const enumerableInputs = { values: [1, 2], label: "inputs" }; +const enumerable = Iterator.zipKeyed(enumerableInputs).toArray(); +// The array's length and methods are not enumerable own properties. +const arrayInputs = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); +// The fallback must not claim that ignored properties exist on yielded objects. +const inheritedLabel = inherited[0].label; +const nonEnumerableLabel = nonEnumerable[0].label; +const precise = Iterator.zipKeyed({ values: [1], [ownKey]: ["a"] }).toArray(); +const preciseLongest = Iterator.zipKeyed({ values: [1] }, { mode: "longest" }).toArray(); +const precisePadded = Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: 0 } }).toArray(); +const emptyOwnProperties = Iterator.zipKeyed({}).toArray(); +Iterator.zipKeyed(0); +Iterator.zipKeyed(null); +Iterator.zipKeyed(instance, { mode: "invalid" }); +Iterator.zipKeyed(instance, { mode: "shortest", padding: {} }); +Iterator.zipKeyed(instance, { mode: "longest", padding: 0 }); +Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: "invalid" } }); + + +//// [iteratorZip.d.ts] +declare const key: unique symbol; +declare const tuples: [number, string][]; +declare const shortestTuples: [number, string][]; +declare const strictTuples: [number, string][]; +declare const longestTuplesWithPadding: [number, string][]; +declare const longestTuplesWithoutPadding: [number | undefined, string | undefined][]; +declare const longestTuplesWithPartialPadding: [number | undefined, string | undefined][]; +declare const maybeLongestOptions: { + mode: "shortest"; +} | { + mode: "longest"; +}; +declare const maybeLongestTuples: [number | undefined, string | undefined][]; +declare const empty: never[]; +declare const emptyLongest: never[]; +declare const iterables: Iterable>; +declare const arrays: number[][]; +declare const longestArrays: (number | undefined)[][]; +declare const maybeLongestArrays: (number | undefined)[][]; +declare const iterableArray: Iterable[]; +declare const longestArrayWithPadding: (number | undefined)[][]; +declare const objects: { + a: number; + b: string; + [key]: boolean; +}[]; +declare const longestObjectsWithPadding: { + a: number; + b: string; +}[]; +declare const longestObjectsWithoutPadding: { + a: number | undefined; + b: string | undefined; +}[]; +declare const longestObjectsWithPartialPadding: { + a: number | undefined; + b: string | undefined; +}[]; +declare const maybeLongestObjects: { + a: number | undefined; + b: string | undefined; +}[]; +interface Inputs { + a: Iterable; + b: Iterator; +} +declare const inputs: Inputs; +declare const rows: { + a: number; + b: string; +}[]; +declare const emptyKeyed: never[]; +declare const emptyKeyedLongest: never[]; +declare const unionInputs: { + a: Iterable; +} | { + b: Iterator; +}; +declare const unionRows: ({ + a: number; +} | { + b: string; +})[]; +declare const a: [string][]; +declare const b: { + a: string; +}[]; +declare const c: (string | undefined)[][]; +declare const d: { + a: number; +}[]; +declare const e: { + a: number; +}[]; +declare const f: never[]; +declare const g: never[]; +interface I { + readonly a: Iterable; + readonly b?: Iterator; + readonly c: Iterable | undefined; + readonly d?: undefined; +} +declare const h: I; +declare const i: { + a: number; + b?: string | undefined; + c?: boolean | undefined; +}[]; +declare const j: { + a: number; + b?: string; + c?: boolean; +}[]; +declare const k: { + a: number; + c: boolean; +}[]; +declare const l: { + a: number | undefined; + b?: string | undefined; + c?: boolean | undefined; +}[]; +declare const m: { + a: Iterable; +} | { + b: Iterator; +}; +declare const n: ({ + a: number; +} | { + b: string; +})[]; +declare const o: { + a: Iterable; +} | { + b: number; +}; +declare const p: { + a?: Iterable; +} | { + b: string; +}; +declare const q: { + a: Iterable; +} | { + b: undefined; +}; +declare const r: { + a: number; +}[]; +declare const s: unique symbol; +declare const t: { + a: Iterable; + [s]?: Iterable; +}; +declare const u: { + a: number; + [s]?: string; +}[]; +declare const v: { + a?: undefined; +}; +declare const w: never[]; +declare const x: { + a: number; +}[]; +declare const y: { + a: number | undefined; +}[]; +declare function f1(a: Iterable): { + b: { + a: T; + }[]; + c: [T][]; +}; +declare const paddingA: [Iterable, ...Iterable[]]; +declare const paddingB: [number, ...(number | undefined)[]][]; +declare const paddingC: (number | undefined)[][]; +declare const paddingD: number[][]; +declare const paddingE: Record>; +declare const paddingF: { + [x: string]: number | undefined; +}[]; +declare const paddingG: Record[]; +declare const paddingH: Record[]; +declare const paddingI: Record; +declare const paddingJ: { + a: number | undefined; + b: number | undefined; +}[]; +declare const paddingK: { + a: number | undefined; + b: number | undefined; +}[]; +declare const paddingL: { + a: number; + b: number; +}[]; +declare const paddingM: [number, string][]; +declare const paddingN: [number, string][]; +declare const paddingO: { + a: number; + b: string; +}[]; +declare const paddingP: { + a: number; + b: string; +}[]; +declare const paddingQ: [number, string | undefined][]; +declare const paddingR: [number | undefined, string | undefined][]; +declare const paddingS: [number, string][]; +declare const paddingT: { + a: number; + b: string | undefined; +}[]; +declare const paddingU: { + a: number | undefined; + b: string | undefined; +}[]; +declare const paddingV: { + a: number; + b: string; +}[]; +declare const paddingW: readonly [number, string]; +declare const paddingX: [number, string][]; +declare const paddingY: [number, string?]; +declare const paddingZ: [number, string | undefined][]; +declare const paddingA1: [number, string][]; +declare const paddingB1: [Iterable] | [Iterable, Iterable]; +declare const paddingC1: ([number] | [number, number | undefined])[]; +declare const paddingD1: number[][]; +declare const paddingE1: { + a: Iterable; +} | { + b: Iterable; +}; +declare const paddingF1: ({ + a: number; +} | { + b: string | undefined; +})[]; +declare const paddingG1: ({ + a: number; +} | { + b: string; +})[]; +declare const paddingH1: { + a: number; +} | { + b: string; +}; +declare const paddingI1: { + a: number | undefined; + b: string | undefined; +}[]; +declare const paddingJ1: { + a: number; + b: string; +}[]; +declare const paddingK1: { + a: number | undefined; + b: number; +}[]; +declare const paddingL1: { + a: number; + b: number; +}[]; +declare const paddingM1: { + [K in `a${string}`]: Iterable; +}; +declare const paddingN1: { + [x: `a${string}`]: number | undefined; +}[]; +declare const paddingO1: { + [K in `a${string}`]: number; +}[]; +declare const paddingP1: unique symbol; +declare const paddingQ1: { + [paddingP1]: number; +}[]; +declare const paddingR1: Record & { + a: number; +}; +declare const paddingS1: { + a: number; + b: number | undefined; +}[]; +declare const paddingT1: { + a: number; + b: number | undefined; +}[]; +declare const paddingU1: { + a: number; + b: number; +}[]; +declare const paddingV1: [number] | [number, string]; +declare const paddingW1: [number, string | undefined][]; +declare const paddingX1: [number, string | undefined][]; +declare const paddingY1: [number, string][]; +declare const paddingZ1: [number | undefined, number][]; +declare const paddingA2: { + a: number | undefined; + b: number; +}[]; +declare class InputsWithPrototypeMembers { + values: number[]; + get label(): string; + describe(): string; +} +declare const instance: InputsWithPrototypeMembers; +declare const inherited: Record[]; +declare const inheritedStrict: Record[]; +declare const inheritedLongest: Record[]; +declare const inheritedPadded: Record[]; +declare const hiddenInputs: { + values: number[]; + label: string; +}; +declare const nonEnumerable: Record[]; +declare const nonEnumerablePadded: Record[]; +declare const enumerableInputs: { + values: number[]; + label: string; +}; +declare const enumerable: Record[]; +declare const arrayInputs: Record[]; +declare const inheritedLabel: string; +declare const nonEnumerableLabel: string; +declare const ownKey: unique symbol; +declare const precise: { + values: number; + [ownKey]: string; +}[]; +declare const preciseLongest: { + values: number | undefined; +}[]; +declare const precisePadded: { + values: number; +}[]; +declare const emptyOwnProperties: never[]; diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).symbols b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).symbols new file mode 100644 index 0000000000000..3314b80fc616e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).symbols @@ -0,0 +1,1368 @@ +//// [tests/cases/compiler/iteratorZip.ts] //// + +=== iteratorZip.ts === +declare const key: unique symbol; +>key : Symbol(key, Decl(iteratorZip.ts, 0, 13)) + +const tuples: [number, string][] = Iterator.zip([ +>tuples : Symbol(tuples, Decl(iteratorZip.ts, 2, 5)) +>Iterator.zip([ [1, 2], new Set(["a", "b"]),] as const).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) + + [1, 2], + new Set(["a", "b"]), +>Set : Symbol(Set, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) + +] as const).toArray(); +>const : Symbol(const) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +tuples[0][0] = 2; +>tuples : Symbol(tuples, Decl(iteratorZip.ts, 2, 5)) +>0 : Symbol(0) + +const shortestTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray(); +>shortestTuples : Symbol(shortestTuples, Decl(iteratorZip.ts, 9, 5)) +>Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>const : Symbol(const) +>mode : Symbol(mode, Decl(iteratorZip.ts, 9, 80)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const strictTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray(); +>strictTuples : Symbol(strictTuples, Decl(iteratorZip.ts, 10, 5)) +>Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>const : Symbol(const) +>mode : Symbol(mode, Decl(iteratorZip.ts, 10, 78)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const longestTuplesWithPadding: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray(); +>longestTuplesWithPadding : Symbol(longestTuplesWithPadding, Decl(iteratorZip.ts, 11, 5)) +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>const : Symbol(const) +>mode : Symbol(mode, Decl(iteratorZip.ts, 11, 90)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 11, 107)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const longestTuplesWithoutPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray(); +>longestTuplesWithoutPadding : Symbol(longestTuplesWithoutPadding, Decl(iteratorZip.ts, 12, 5)) +>Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>const : Symbol(const) +>mode : Symbol(mode, Decl(iteratorZip.ts, 12, 117)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const longestTuplesWithPartialPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray(); +>longestTuplesWithPartialPadding : Symbol(longestTuplesWithPartialPadding, Decl(iteratorZip.ts, 13, 5)) +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>const : Symbol(const) +>mode : Symbol(mode, Decl(iteratorZip.ts, 13, 121)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 13, 138)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const maybeLongestOptions: { mode: "shortest"; } | { mode: "longest"; }; +>maybeLongestOptions : Symbol(maybeLongestOptions, Decl(iteratorZip.ts, 15, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 15, 36)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 15, 60)) + +const maybeLongestTuples: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray(); +>maybeLongestTuples : Symbol(maybeLongestTuples, Decl(iteratorZip.ts, 16, 5)) +>Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>const : Symbol(const) +>maybeLongestOptions : Symbol(maybeLongestOptions, Decl(iteratorZip.ts, 15, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const empty: never[] = Iterator.zip([]).toArray(); +>empty : Symbol(empty, Decl(iteratorZip.ts, 18, 5)) +>Iterator.zip([]).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const emptyLongest: never[] = Iterator.zip([], { mode: "longest" }).toArray(); +>emptyLongest : Symbol(emptyLongest, Decl(iteratorZip.ts, 19, 5)) +>Iterator.zip([], { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZip.ts, 19, 48)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const iterables: Iterable>; +>iterables : Symbol(iterables, Decl(iteratorZip.ts, 21, 13)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + +const arrays: number[][] = Iterator.zip(iterables).toArray(); +>arrays : Symbol(arrays, Decl(iteratorZip.ts, 22, 5)) +>Iterator.zip(iterables).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>iterables : Symbol(iterables, Decl(iteratorZip.ts, 21, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const longestArrays: (number | undefined)[][] = Iterator.zip(iterables, { mode: "longest" }).toArray(); +>longestArrays : Symbol(longestArrays, Decl(iteratorZip.ts, 23, 5)) +>Iterator.zip(iterables, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>iterables : Symbol(iterables, Decl(iteratorZip.ts, 21, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 23, 73)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const maybeLongestArrays: (number | undefined)[][] = Iterator.zip(iterables, maybeLongestOptions).toArray(); +>maybeLongestArrays : Symbol(maybeLongestArrays, Decl(iteratorZip.ts, 24, 5)) +>Iterator.zip(iterables, maybeLongestOptions).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>iterables : Symbol(iterables, Decl(iteratorZip.ts, 21, 13)) +>maybeLongestOptions : Symbol(maybeLongestOptions, Decl(iteratorZip.ts, 15, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const iterableArray: Iterable[]; +>iterableArray : Symbol(iterableArray, Decl(iteratorZip.ts, 26, 13)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + +const longestArrayWithPadding: (number | undefined)[][] = Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray(); +>longestArrayWithPadding : Symbol(longestArrayWithPadding, Decl(iteratorZip.ts, 27, 5)) +>Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>iterableArray : Symbol(iterableArray, Decl(iteratorZip.ts, 26, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 27, 87)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 27, 104)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ +>objects : Symbol(objects, Decl(iteratorZip.ts, 29, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 29, 16)) +>b : Symbol(b, Decl(iteratorZip.ts, 29, 27)) +>[key] : Symbol([key], Decl(iteratorZip.ts, 29, 38)) +>key : Symbol(key, Decl(iteratorZip.ts, 0, 13)) +>Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) + + a: [1, 2], +>a : Symbol(a, Decl(iteratorZip.ts, 29, 80)) + + b: new Set(["a", "b"]), +>b : Symbol(b, Decl(iteratorZip.ts, 30, 14)) +>Set : Symbol(Set, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) + + [key]: [true, false], +>[key] : Symbol([key], Decl(iteratorZip.ts, 31, 27)) +>key : Symbol(key, Decl(iteratorZip.ts, 0, 13)) + +} as const).toArray(); +>const : Symbol(const) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +objects[0].a = 2; +>objects[0].a : Symbol(a, Decl(iteratorZip.ts, 29, 16)) +>objects : Symbol(objects, Decl(iteratorZip.ts, 29, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 29, 16)) + +const longestObjectsWithPadding: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +>longestObjectsWithPadding : Symbol(longestObjectsWithPadding, Decl(iteratorZip.ts, 37, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 37, 34)) +>b : Symbol(b, Decl(iteratorZip.ts, 37, 45)) +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 37, 82)) +>b : Symbol(b, Decl(iteratorZip.ts, 37, 90)) +>const : Symbol(const) + + mode: "longest", +>mode : Symbol(mode, Decl(iteratorZip.ts, 37, 113)) + + padding: { a: 1, b: "a" }, +>padding : Symbol(padding, Decl(iteratorZip.ts, 38, 20)) +>a : Symbol(a, Decl(iteratorZip.ts, 39, 14)) +>b : Symbol(b, Decl(iteratorZip.ts, 39, 20)) + +}).toArray(); +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const longestObjectsWithoutPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +>longestObjectsWithoutPadding : Symbol(longestObjectsWithoutPadding, Decl(iteratorZip.ts, 42, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 42, 37)) +>b : Symbol(b, Decl(iteratorZip.ts, 42, 60)) +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 42, 109)) +>b : Symbol(b, Decl(iteratorZip.ts, 42, 117)) +>const : Symbol(const) + + mode: "longest", +>mode : Symbol(mode, Decl(iteratorZip.ts, 42, 140)) + +}).toArray(); +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const longestObjectsWithPartialPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +>longestObjectsWithPartialPadding : Symbol(longestObjectsWithPartialPadding, Decl(iteratorZip.ts, 46, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 46, 41)) +>b : Symbol(b, Decl(iteratorZip.ts, 46, 64)) +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 46, 113)) +>b : Symbol(b, Decl(iteratorZip.ts, 46, 121)) +>const : Symbol(const) + + mode: "longest", +>mode : Symbol(mode, Decl(iteratorZip.ts, 46, 144)) + + padding: { b: "a" }, +>padding : Symbol(padding, Decl(iteratorZip.ts, 47, 20)) +>b : Symbol(b, Decl(iteratorZip.ts, 48, 14)) + +}).toArray(); +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const maybeLongestObjects: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray(); +>maybeLongestObjects : Symbol(maybeLongestObjects, Decl(iteratorZip.ts, 51, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 51, 28)) +>b : Symbol(b, Decl(iteratorZip.ts, 51, 51)) +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 51, 100)) +>b : Symbol(b, Decl(iteratorZip.ts, 51, 108)) +>const : Symbol(const) +>maybeLongestOptions : Symbol(maybeLongestOptions, Decl(iteratorZip.ts, 15, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +interface Inputs { +>Inputs : Symbol(Inputs, Decl(iteratorZip.ts, 51, 161)) + + a: Iterable; +>a : Symbol(Inputs.a, Decl(iteratorZip.ts, 53, 18)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + + b: Iterator; +>b : Symbol(Inputs.b, Decl(iteratorZip.ts, 54, 24)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +} + +declare const inputs: Inputs; +>inputs : Symbol(inputs, Decl(iteratorZip.ts, 58, 13)) +>Inputs : Symbol(Inputs, Decl(iteratorZip.ts, 51, 161)) + +const rows: { a: number; b: string; }[] = Iterator.zipKeyed(inputs).toArray(); +>rows : Symbol(rows, Decl(iteratorZip.ts, 59, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 59, 13)) +>b : Symbol(b, Decl(iteratorZip.ts, 59, 24)) +>Iterator.zipKeyed(inputs).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>inputs : Symbol(inputs, Decl(iteratorZip.ts, 58, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +Iterator.zip([[1]], { mode: "invalid" }); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZip.ts, 61, 21)) + +Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>const : Symbol(const) +>mode : Symbol(mode, Decl(iteratorZip.ts, 63, 37)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 63, 54)) + +Iterator.zip([[1]], { mode: "shortest", padding: [1] }); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZip.ts, 65, 21)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 65, 39)) + +Iterator.zip(0); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) + +Iterator.zipKeyed({ a: 0 }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 69, 19)) + +const emptyKeyed: never[] = Iterator.zipKeyed({}).toArray(); +>emptyKeyed : Symbol(emptyKeyed, Decl(iteratorZip.ts, 71, 5)) +>Iterator.zipKeyed({}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const emptyKeyedLongest: never[] = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); +>emptyKeyedLongest : Symbol(emptyKeyedLongest, Decl(iteratorZip.ts, 72, 5)) +>Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 72, 58)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 72, 75)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const unionInputs: { a: Iterable; } | { b: Iterator; }; +>unionInputs : Symbol(unionInputs, Decl(iteratorZip.ts, 74, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 74, 28)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>b : Symbol(b, Decl(iteratorZip.ts, 74, 55)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) + +const unionRows: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(unionInputs).toArray(); +>unionRows : Symbol(unionRows, Decl(iteratorZip.ts, 75, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 75, 19)) +>b : Symbol(b, Decl(iteratorZip.ts, 75, 36)) +>Iterator.zipKeyed(unionInputs).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>unionInputs : Symbol(unionInputs, Decl(iteratorZip.ts, 74, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +// Inputs + +Iterator.zip("ab"); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) + +Iterator.zip(["ab"]); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) + +Iterator.zip(new Set(["ab"])); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Set : Symbol(Set, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) + +Iterator.zipKeyed("ab"); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) + +Iterator.zipKeyed({ a: "ab" }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 83, 19)) + +Iterator.zip([], { mode: "longest", padding: "ab" }); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZip.ts, 84, 18)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 84, 35)) + +Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZip.ts, 85, 23)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 85, 40)) + +Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 86, 23)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 86, 40)) + +const a: [string][] = Iterator.zip([new String("ab")]).toArray(); +>a : Symbol(a, Decl(iteratorZip.ts, 88, 5)) +>Iterator.zip([new String("ab")]).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const b: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); +>b : Symbol(b, Decl(iteratorZip.ts, 89, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 89, 10)) +>Iterator.zipKeyed({ a: new String("ab") }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 89, 47)) +>String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const c: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); +>c : Symbol(c, Decl(iteratorZip.ts, 90, 5)) +>Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZip.ts, 90, 59)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 90, 76)) +>String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); +>d : Symbol(d, Decl(iteratorZip.ts, 92, 5)) +>Iterator.zipKeyed({ a: [1], b: undefined }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 92, 29)) +>b : Symbol(b, Decl(iteratorZip.ts, 92, 37)) +>undefined : Symbol(undefined) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const e: { a: number; }[] = d; +>e : Symbol(e, Decl(iteratorZip.ts, 93, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 93, 10)) +>d : Symbol(d, Decl(iteratorZip.ts, 92, 5)) + +d[0].b; +>d : Symbol(d, Decl(iteratorZip.ts, 92, 5)) + +const f: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); +>f : Symbol(f, Decl(iteratorZip.ts, 95, 5)) +>Iterator.zipKeyed({ a: undefined }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 95, 38)) +>undefined : Symbol(undefined) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const g: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); +>g : Symbol(g, Decl(iteratorZip.ts, 96, 5)) +>Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 96, 38)) +>undefined : Symbol(undefined) +>mode : Symbol(mode, Decl(iteratorZip.ts, 96, 56)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 96, 73)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +interface I { +>I : Symbol(I, Decl(iteratorZip.ts, 96, 99)) + + readonly a: Iterable; +>a : Symbol(I.a, Decl(iteratorZip.ts, 98, 13)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + + readonly b?: Iterator; +>b : Symbol(I.b, Decl(iteratorZip.ts, 99, 33)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) + + readonly c: Iterable | undefined; +>c : Symbol(I.c, Decl(iteratorZip.ts, 100, 34)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + + readonly d?: undefined; +>d : Symbol(I.d, Decl(iteratorZip.ts, 101, 46)) +} +declare const h: I; +>h : Symbol(h, Decl(iteratorZip.ts, 104, 13)) +>I : Symbol(I, Decl(iteratorZip.ts, 96, 99)) + +const i = Iterator.zipKeyed(h).toArray(); +>i : Symbol(i, Decl(iteratorZip.ts, 105, 5)) +>Iterator.zipKeyed(h).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>h : Symbol(h, Decl(iteratorZip.ts, 104, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const j: { a: number; b?: string; c?: boolean; }[] = i; +>j : Symbol(j, Decl(iteratorZip.ts, 106, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 106, 10)) +>b : Symbol(b, Decl(iteratorZip.ts, 106, 21)) +>c : Symbol(c, Decl(iteratorZip.ts, 106, 33)) +>i : Symbol(i, Decl(iteratorZip.ts, 105, 5)) + +i[0].a = 2; +>i[0].a : Symbol(a, Decl(iteratorZip.ts, 98, 13)) +>i : Symbol(i, Decl(iteratorZip.ts, 105, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 98, 13)) + +i[0].b = "a"; +>i[0].b : Symbol(b, Decl(iteratorZip.ts, 99, 33)) +>i : Symbol(i, Decl(iteratorZip.ts, 105, 5)) +>b : Symbol(b, Decl(iteratorZip.ts, 99, 33)) + +i[0].c = true; +>i[0].c : Symbol(c, Decl(iteratorZip.ts, 100, 34)) +>i : Symbol(i, Decl(iteratorZip.ts, 105, 5)) +>c : Symbol(c, Decl(iteratorZip.ts, 100, 34)) + +i[0].d; +>i : Symbol(i, Decl(iteratorZip.ts, 105, 5)) + +const k: { a: number; c: boolean; }[] = i; +>k : Symbol(k, Decl(iteratorZip.ts, 111, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 111, 10)) +>c : Symbol(c, Decl(iteratorZip.ts, 111, 21)) +>i : Symbol(i, Decl(iteratorZip.ts, 105, 5)) + +const l: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); +>l : Symbol(l, Decl(iteratorZip.ts, 112, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 112, 10)) +>b : Symbol(b, Decl(iteratorZip.ts, 112, 33)) +>c : Symbol(c, Decl(iteratorZip.ts, 112, 57)) +>Iterator.zipKeyed(h, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>h : Symbol(h, Decl(iteratorZip.ts, 104, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 112, 111)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const m: { a: Iterable; } | { b: Iterator; }; +>m : Symbol(m, Decl(iteratorZip.ts, 114, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 114, 18)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>b : Symbol(b, Decl(iteratorZip.ts, 114, 45)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) + +const n: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(m).toArray(); +>n : Symbol(n, Decl(iteratorZip.ts, 115, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 115, 11)) +>b : Symbol(b, Decl(iteratorZip.ts, 115, 28)) +>Iterator.zipKeyed(m).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>m : Symbol(m, Decl(iteratorZip.ts, 114, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const o: { a: Iterable; } | { b: number; }; +>o : Symbol(o, Decl(iteratorZip.ts, 116, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 116, 18)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>b : Symbol(b, Decl(iteratorZip.ts, 116, 45)) + +Iterator.zipKeyed(o); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>o : Symbol(o, Decl(iteratorZip.ts, 116, 13)) + +Iterator.zipKeyed(o, { mode: "longest" }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>o : Symbol(o, Decl(iteratorZip.ts, 116, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 118, 22)) + +Iterator.zipKeyed(o, { mode: "longest", padding: {} }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>o : Symbol(o, Decl(iteratorZip.ts, 116, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 119, 22)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 119, 39)) + +declare const p: { a?: Iterable; } | { b: string; }; +>p : Symbol(p, Decl(iteratorZip.ts, 120, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 120, 18)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>b : Symbol(b, Decl(iteratorZip.ts, 120, 46)) + +Iterator.zipKeyed(p); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>p : Symbol(p, Decl(iteratorZip.ts, 120, 13)) + +declare const q: { a: Iterable; } | { b: undefined; }; +>q : Symbol(q, Decl(iteratorZip.ts, 122, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 122, 18)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>b : Symbol(b, Decl(iteratorZip.ts, 122, 45)) + +const r: { a: number; }[] = Iterator.zipKeyed(q).toArray(); +>r : Symbol(r, Decl(iteratorZip.ts, 123, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 123, 10)) +>Iterator.zipKeyed(q).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>q : Symbol(q, Decl(iteratorZip.ts, 122, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const s: unique symbol; +>s : Symbol(s, Decl(iteratorZip.ts, 125, 13)) + +declare const t: { a: Iterable; [s]?: Iterable; }; +>t : Symbol(t, Decl(iteratorZip.ts, 126, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 126, 18)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>[s] : Symbol([s], Decl(iteratorZip.ts, 126, 39)) +>s : Symbol(s, Decl(iteratorZip.ts, 125, 13)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + +const u: { a: number; [s]?: string; }[] = Iterator.zipKeyed(t).toArray(); +>u : Symbol(u, Decl(iteratorZip.ts, 127, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 127, 10)) +>[s] : Symbol([s], Decl(iteratorZip.ts, 127, 21)) +>s : Symbol(s, Decl(iteratorZip.ts, 125, 13)) +>Iterator.zipKeyed(t).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>t : Symbol(t, Decl(iteratorZip.ts, 126, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +Iterator.zipKeyed({ a: [1], b: null }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 129, 19)) +>b : Symbol(b, Decl(iteratorZip.ts, 129, 27)) + +Iterator.zipKeyed({ a: [1], b: false }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 130, 19)) +>b : Symbol(b, Decl(iteratorZip.ts, 130, 27)) + +Iterator.zip([undefined]); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>undefined : Symbol(undefined) + +declare const v: { a?: undefined; }; +>v : Symbol(v, Decl(iteratorZip.ts, 133, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 133, 18)) + +const w: never[] = Iterator.zipKeyed(v).toArray(); +>w : Symbol(w, Decl(iteratorZip.ts, 134, 5)) +>Iterator.zipKeyed(v).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>v : Symbol(v, Decl(iteratorZip.ts, 133, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const x: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); +>x : Symbol(x, Decl(iteratorZip.ts, 135, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 135, 10)) +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 135, 47)) +>b : Symbol(b, Decl(iteratorZip.ts, 135, 55)) +>undefined : Symbol(undefined) +>mode : Symbol(mode, Decl(iteratorZip.ts, 135, 73)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 135, 90)) +>a : Symbol(a, Decl(iteratorZip.ts, 135, 101)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const y: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); +>y : Symbol(y, Decl(iteratorZip.ts, 136, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 136, 10)) +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 136, 59)) +>b : Symbol(b, Decl(iteratorZip.ts, 136, 67)) +>undefined : Symbol(undefined) +>mode : Symbol(mode, Decl(iteratorZip.ts, 136, 85)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +function f1(a: Iterable) { +>f1 : Symbol(f1, Decl(iteratorZip.ts, 136, 115)) +>T : Symbol(T, Decl(iteratorZip.ts, 138, 12)) +>a : Symbol(a, Decl(iteratorZip.ts, 138, 15)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>T : Symbol(T, Decl(iteratorZip.ts, 138, 12)) + + const b: { a: T; }[] = Iterator.zipKeyed({ a }).toArray(); +>b : Symbol(b, Decl(iteratorZip.ts, 139, 9)) +>a : Symbol(a, Decl(iteratorZip.ts, 139, 14)) +>T : Symbol(T, Decl(iteratorZip.ts, 138, 12)) +>Iterator.zipKeyed({ a }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 139, 46)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + + const c: [T][] = Iterator.zip([a]).toArray(); +>c : Symbol(c, Decl(iteratorZip.ts, 140, 9)) +>T : Symbol(T, Decl(iteratorZip.ts, 138, 12)) +>Iterator.zip([a]).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>a : Symbol(a, Decl(iteratorZip.ts, 138, 15)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + + return { b, c }; +>b : Symbol(b, Decl(iteratorZip.ts, 141, 12)) +>c : Symbol(c, Decl(iteratorZip.ts, 141, 15)) +} + +// Padding + +const paddingA: [Iterable, ...Iterable[]] = [[1, 2], [3]]; +>paddingA : Symbol(paddingA, Decl(iteratorZip.ts, 146, 5)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + +const paddingB = Iterator.zip(paddingA, { mode: "longest", padding: [0] }).toArray(); +>paddingB : Symbol(paddingB, Decl(iteratorZip.ts, 147, 5)) +>Iterator.zip(paddingA, { mode: "longest", padding: [0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>paddingA : Symbol(paddingA, Decl(iteratorZip.ts, 146, 5)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 147, 41)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 147, 58)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const paddingC: (number | undefined)[][] = paddingB; +>paddingC : Symbol(paddingC, Decl(iteratorZip.ts, 148, 5)) +>paddingB : Symbol(paddingB, Decl(iteratorZip.ts, 147, 5)) + +const paddingD: number[][] = paddingB; +>paddingD : Symbol(paddingD, Decl(iteratorZip.ts, 149, 5)) +>paddingB : Symbol(paddingB, Decl(iteratorZip.ts, 147, 5)) + +const paddingE: Record> = { a: [1], b: [2, 3] }; +>paddingE : Symbol(paddingE, Decl(iteratorZip.ts, 151, 5)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 151, 52)) +>b : Symbol(b, Decl(iteratorZip.ts, 151, 60)) + +const paddingF = Iterator.zipKeyed(paddingE, { mode: "longest", padding: {} }).toArray(); +>paddingF : Symbol(paddingF, Decl(iteratorZip.ts, 152, 5)) +>Iterator.zipKeyed(paddingE, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>paddingE : Symbol(paddingE, Decl(iteratorZip.ts, 151, 5)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 152, 46)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 152, 63)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const paddingG: Record[] = paddingF; +>paddingG : Symbol(paddingG, Decl(iteratorZip.ts, 153, 5)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>paddingF : Symbol(paddingF, Decl(iteratorZip.ts, 152, 5)) + +const paddingH: Record[] = paddingF; +>paddingH : Symbol(paddingH, Decl(iteratorZip.ts, 154, 5)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>paddingF : Symbol(paddingF, Decl(iteratorZip.ts, 152, 5)) + +declare const paddingI: Record; +>paddingI : Symbol(paddingI, Decl(iteratorZip.ts, 156, 13)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) + +const paddingJ = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: paddingI }).toArray(); +>paddingJ : Symbol(paddingJ, Decl(iteratorZip.ts, 157, 5)) +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: paddingI }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 157, 36)) +>b : Symbol(b, Decl(iteratorZip.ts, 157, 44)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 157, 59)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 157, 76)) +>paddingI : Symbol(paddingI, Decl(iteratorZip.ts, 156, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const paddingK: { a: number | undefined; b: number | undefined; }[] = paddingJ; +>paddingK : Symbol(paddingK, Decl(iteratorZip.ts, 158, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 158, 17)) +>b : Symbol(b, Decl(iteratorZip.ts, 158, 40)) +>paddingJ : Symbol(paddingJ, Decl(iteratorZip.ts, 157, 5)) + +const paddingL: { a: number; b: number; }[] = paddingJ; +>paddingL : Symbol(paddingL, Decl(iteratorZip.ts, 159, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 159, 17)) +>b : Symbol(b, Decl(iteratorZip.ts, 159, 28)) +>paddingJ : Symbol(paddingJ, Decl(iteratorZip.ts, 157, 5)) + +const paddingM = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); +>paddingM : Symbol(paddingM, Decl(iteratorZip.ts, 161, 5)) +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZip.ts, 161, 45)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 161, 62)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const paddingN: [number, string][] = paddingM; +>paddingN : Symbol(paddingN, Decl(iteratorZip.ts, 162, 5)) +>paddingM : Symbol(paddingM, Decl(iteratorZip.ts, 161, 5)) + +const paddingO = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); +>paddingO : Symbol(paddingO, Decl(iteratorZip.ts, 163, 5)) +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 163, 36)) +>b : Symbol(b, Decl(iteratorZip.ts, 163, 44)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 163, 58)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 163, 75)) +>a : Symbol(a, Decl(iteratorZip.ts, 163, 86)) +>b : Symbol(b, Decl(iteratorZip.ts, 163, 92)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const paddingP: { a: number; b: string; }[] = paddingO; +>paddingP : Symbol(paddingP, Decl(iteratorZip.ts, 164, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 164, 17)) +>b : Symbol(b, Decl(iteratorZip.ts, 164, 28)) +>paddingO : Symbol(paddingO, Decl(iteratorZip.ts, 163, 5)) + +const paddingQ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); +>paddingQ : Symbol(paddingQ, Decl(iteratorZip.ts, 166, 5)) +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZip.ts, 166, 45)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 166, 62)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const paddingR: [number | undefined, string | undefined][] = paddingQ; +>paddingR : Symbol(paddingR, Decl(iteratorZip.ts, 167, 5)) +>paddingQ : Symbol(paddingQ, Decl(iteratorZip.ts, 166, 5)) + +const paddingS: [number, string][] = paddingQ; +>paddingS : Symbol(paddingS, Decl(iteratorZip.ts, 168, 5)) +>paddingQ : Symbol(paddingQ, Decl(iteratorZip.ts, 166, 5)) + +const paddingT = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); +>paddingT : Symbol(paddingT, Decl(iteratorZip.ts, 169, 5)) +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 169, 36)) +>b : Symbol(b, Decl(iteratorZip.ts, 169, 44)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 169, 58)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 169, 75)) +>a : Symbol(a, Decl(iteratorZip.ts, 169, 86)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const paddingU: { a: number | undefined; b: string | undefined; }[] = paddingT; +>paddingU : Symbol(paddingU, Decl(iteratorZip.ts, 170, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 170, 17)) +>b : Symbol(b, Decl(iteratorZip.ts, 170, 40)) +>paddingT : Symbol(paddingT, Decl(iteratorZip.ts, 169, 5)) + +const paddingV: { a: number; b: string; }[] = paddingT; +>paddingV : Symbol(paddingV, Decl(iteratorZip.ts, 171, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 171, 17)) +>b : Symbol(b, Decl(iteratorZip.ts, 171, 28)) +>paddingT : Symbol(paddingT, Decl(iteratorZip.ts, 169, 5)) + +declare const paddingW: readonly [number, string]; +>paddingW : Symbol(paddingW, Decl(iteratorZip.ts, 173, 13)) + +const paddingX: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingW }).toArray(); +>paddingX : Symbol(paddingX, Decl(iteratorZip.ts, 174, 5)) +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingW }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZip.ts, 174, 65)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 174, 82)) +>paddingW : Symbol(paddingW, Decl(iteratorZip.ts, 173, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const paddingY: [number, string?]; +>paddingY : Symbol(paddingY, Decl(iteratorZip.ts, 175, 13)) + +const paddingZ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY }).toArray(); +>paddingZ : Symbol(paddingZ, Decl(iteratorZip.ts, 176, 5)) +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZip.ts, 176, 45)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 176, 62)) +>paddingY : Symbol(paddingY, Decl(iteratorZip.ts, 175, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const paddingA1: [number, string][] = paddingZ; +>paddingA1 : Symbol(paddingA1, Decl(iteratorZip.ts, 177, 5)) +>paddingZ : Symbol(paddingZ, Decl(iteratorZip.ts, 176, 5)) + +declare const paddingB1: [Iterable] | [Iterable, Iterable]; +>paddingB1 : Symbol(paddingB1, Decl(iteratorZip.ts, 179, 13)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + +const paddingC1 = Iterator.zip(paddingB1, { mode: "longest", padding: [0] }).toArray(); +>paddingC1 : Symbol(paddingC1, Decl(iteratorZip.ts, 180, 5)) +>Iterator.zip(paddingB1, { mode: "longest", padding: [0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>paddingB1 : Symbol(paddingB1, Decl(iteratorZip.ts, 179, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 180, 43)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 180, 60)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const paddingD1: number[][] = paddingC1; +>paddingD1 : Symbol(paddingD1, Decl(iteratorZip.ts, 181, 5)) +>paddingC1 : Symbol(paddingC1, Decl(iteratorZip.ts, 180, 5)) + +declare const paddingE1: { a: Iterable; } | { b: Iterable; }; +>paddingE1 : Symbol(paddingE1, Decl(iteratorZip.ts, 182, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 182, 26)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>b : Symbol(b, Decl(iteratorZip.ts, 182, 53)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + +const paddingF1 = Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: 0 } }).toArray(); +>paddingF1 : Symbol(paddingF1, Decl(iteratorZip.ts, 183, 5)) +>Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>paddingE1 : Symbol(paddingE1, Decl(iteratorZip.ts, 182, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 183, 48)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 183, 65)) +>a : Symbol(a, Decl(iteratorZip.ts, 183, 76)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const paddingG1: ({ a: number; } | { b: string; })[] = paddingF1; +>paddingG1 : Symbol(paddingG1, Decl(iteratorZip.ts, 184, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 184, 19)) +>b : Symbol(b, Decl(iteratorZip.ts, 184, 36)) +>paddingF1 : Symbol(paddingF1, Decl(iteratorZip.ts, 183, 5)) + +declare const paddingH1: { a: number; } | { b: string; }; +>paddingH1 : Symbol(paddingH1, Decl(iteratorZip.ts, 186, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 186, 26)) +>b : Symbol(b, Decl(iteratorZip.ts, 186, 43)) + +const paddingI1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: paddingH1 }).toArray(); +>paddingI1 : Symbol(paddingI1, Decl(iteratorZip.ts, 187, 5)) +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: paddingH1 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 187, 37)) +>b : Symbol(b, Decl(iteratorZip.ts, 187, 45)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 187, 59)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 187, 76)) +>paddingH1 : Symbol(paddingH1, Decl(iteratorZip.ts, 186, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const paddingJ1: { a: number; b: string; }[] = paddingI1; +>paddingJ1 : Symbol(paddingJ1, Decl(iteratorZip.ts, 188, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 188, 18)) +>b : Symbol(b, Decl(iteratorZip.ts, 188, 29)) +>paddingI1 : Symbol(paddingI1, Decl(iteratorZip.ts, 187, 5)) + +const paddingK1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); +>paddingK1 : Symbol(paddingK1, Decl(iteratorZip.ts, 190, 5)) +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 190, 37)) +>b : Symbol(b, Decl(iteratorZip.ts, 190, 45)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 190, 57)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 190, 74)) +>a : Symbol(a, Decl(iteratorZip.ts, 190, 85)) +>undefined : Symbol(undefined) +>b : Symbol(b, Decl(iteratorZip.ts, 190, 99)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const paddingL1: { a: number; b: number; }[] = paddingK1; +>paddingL1 : Symbol(paddingL1, Decl(iteratorZip.ts, 191, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 191, 18)) +>b : Symbol(b, Decl(iteratorZip.ts, 191, 29)) +>paddingK1 : Symbol(paddingK1, Decl(iteratorZip.ts, 190, 5)) + +declare const paddingM1: { [K in `a${string}`]: Iterable; }; +>paddingM1 : Symbol(paddingM1, Decl(iteratorZip.ts, 193, 13)) +>K : Symbol(K, Decl(iteratorZip.ts, 193, 28)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + +const paddingN1 = Iterator.zipKeyed(paddingM1, { mode: "longest", padding: {} }).toArray(); +>paddingN1 : Symbol(paddingN1, Decl(iteratorZip.ts, 194, 5)) +>Iterator.zipKeyed(paddingM1, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>paddingM1 : Symbol(paddingM1, Decl(iteratorZip.ts, 193, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 194, 48)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 194, 65)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const paddingO1: { [K in `a${string}`]: number; }[] = paddingN1; +>paddingO1 : Symbol(paddingO1, Decl(iteratorZip.ts, 195, 5)) +>K : Symbol(K, Decl(iteratorZip.ts, 195, 20)) +>paddingN1 : Symbol(paddingN1, Decl(iteratorZip.ts, 194, 5)) + +declare const paddingP1: unique symbol; +>paddingP1 : Symbol(paddingP1, Decl(iteratorZip.ts, 197, 13)) + +const paddingQ1: { [paddingP1]: number; }[] = Iterator.zipKeyed({ [paddingP1]: [1] }, { mode: "longest", padding: { [paddingP1]: 0 } }).toArray(); +>paddingQ1 : Symbol(paddingQ1, Decl(iteratorZip.ts, 198, 5)) +>[paddingP1] : Symbol([paddingP1], Decl(iteratorZip.ts, 198, 18)) +>paddingP1 : Symbol(paddingP1, Decl(iteratorZip.ts, 197, 13)) +>Iterator.zipKeyed({ [paddingP1]: [1] }, { mode: "longest", padding: { [paddingP1]: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>[paddingP1] : Symbol([paddingP1], Decl(iteratorZip.ts, 198, 65)) +>paddingP1 : Symbol(paddingP1, Decl(iteratorZip.ts, 197, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 198, 87)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 198, 104)) +>[paddingP1] : Symbol([paddingP1], Decl(iteratorZip.ts, 198, 115)) +>paddingP1 : Symbol(paddingP1, Decl(iteratorZip.ts, 197, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const paddingR1: Record & { a: number; }; +>paddingR1 : Symbol(paddingR1, Decl(iteratorZip.ts, 200, 13)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 200, 51)) + +const paddingS1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: paddingR1 }).toArray(); +>paddingS1 : Symbol(paddingS1, Decl(iteratorZip.ts, 201, 5)) +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: paddingR1 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 201, 37)) +>b : Symbol(b, Decl(iteratorZip.ts, 201, 45)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 201, 57)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 201, 74)) +>paddingR1 : Symbol(paddingR1, Decl(iteratorZip.ts, 200, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const paddingT1: { a: number; b: number | undefined; }[] = paddingS1; +>paddingT1 : Symbol(paddingT1, Decl(iteratorZip.ts, 202, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 202, 18)) +>b : Symbol(b, Decl(iteratorZip.ts, 202, 29)) +>paddingS1 : Symbol(paddingS1, Decl(iteratorZip.ts, 201, 5)) + +const paddingU1: { a: number; b: number; }[] = paddingS1; +>paddingU1 : Symbol(paddingU1, Decl(iteratorZip.ts, 203, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 203, 18)) +>b : Symbol(b, Decl(iteratorZip.ts, 203, 29)) +>paddingS1 : Symbol(paddingS1, Decl(iteratorZip.ts, 201, 5)) + +declare const paddingV1: [number] | [number, string]; +>paddingV1 : Symbol(paddingV1, Decl(iteratorZip.ts, 205, 13)) + +const paddingW1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingV1 }).toArray(); +>paddingW1 : Symbol(paddingW1, Decl(iteratorZip.ts, 206, 5)) +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingV1 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZip.ts, 206, 46)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 206, 63)) +>paddingV1 : Symbol(paddingV1, Decl(iteratorZip.ts, 205, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const paddingX1: [number, string | undefined][] = paddingW1; +>paddingX1 : Symbol(paddingX1, Decl(iteratorZip.ts, 207, 5)) +>paddingW1 : Symbol(paddingW1, Decl(iteratorZip.ts, 206, 5)) + +const paddingY1: [number, string][] = paddingW1; +>paddingY1 : Symbol(paddingY1, Decl(iteratorZip.ts, 208, 5)) +>paddingW1 : Symbol(paddingW1, Decl(iteratorZip.ts, 206, 5)) + +const paddingZ1: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); +>paddingZ1 : Symbol(paddingZ1, Decl(iteratorZip.ts, 210, 5)) +>Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZip.ts, 210, 76)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 210, 93)) +>undefined : Symbol(undefined) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const paddingA2: { a: number | undefined; b: number; }[] = paddingK1; +>paddingA2 : Symbol(paddingA2, Decl(iteratorZip.ts, 211, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 211, 18)) +>b : Symbol(b, Decl(iteratorZip.ts, 211, 41)) +>paddingK1 : Symbol(paddingK1, Decl(iteratorZip.ts, 190, 5)) + +// Own properties + +class InputsWithPrototypeMembers { +>InputsWithPrototypeMembers : Symbol(InputsWithPrototypeMembers, Decl(iteratorZip.ts, 211, 69)) + + values = [1, 2]; +>values : Symbol(InputsWithPrototypeMembers.values, Decl(iteratorZip.ts, 215, 34)) + + get label() { +>label : Symbol(InputsWithPrototypeMembers.label, Decl(iteratorZip.ts, 216, 20)) + + return "inputs"; + } + + describe() { +>describe : Symbol(InputsWithPrototypeMembers.describe, Decl(iteratorZip.ts, 220, 5)) + + return this.label; +>this.label : Symbol(InputsWithPrototypeMembers.label, Decl(iteratorZip.ts, 216, 20)) +>this : Symbol(InputsWithPrototypeMembers, Decl(iteratorZip.ts, 211, 69)) +>label : Symbol(InputsWithPrototypeMembers.label, Decl(iteratorZip.ts, 216, 20)) + } +} + +const instance = new InputsWithPrototypeMembers(); +>instance : Symbol(instance, Decl(iteratorZip.ts, 227, 5)) +>InputsWithPrototypeMembers : Symbol(InputsWithPrototypeMembers, Decl(iteratorZip.ts, 211, 69)) + +const inherited = Iterator.zipKeyed(instance).toArray(); +>inherited : Symbol(inherited, Decl(iteratorZip.ts, 228, 5)) +>Iterator.zipKeyed(instance).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>instance : Symbol(instance, Decl(iteratorZip.ts, 227, 5)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const inheritedStrict = Iterator.zipKeyed(instance, { mode: "strict" }).toArray(); +>inheritedStrict : Symbol(inheritedStrict, Decl(iteratorZip.ts, 229, 5)) +>Iterator.zipKeyed(instance, { mode: "strict" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>instance : Symbol(instance, Decl(iteratorZip.ts, 227, 5)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 229, 53)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const inheritedLongest = Iterator.zipKeyed(instance, { mode: "longest" }).toArray(); +>inheritedLongest : Symbol(inheritedLongest, Decl(iteratorZip.ts, 230, 5)) +>Iterator.zipKeyed(instance, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>instance : Symbol(instance, Decl(iteratorZip.ts, 227, 5)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 230, 54)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const inheritedPadded = Iterator.zipKeyed(instance, { mode: "longest", padding: { values: 0 } }).toArray(); +>inheritedPadded : Symbol(inheritedPadded, Decl(iteratorZip.ts, 231, 5)) +>Iterator.zipKeyed(instance, { mode: "longest", padding: { values: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>instance : Symbol(instance, Decl(iteratorZip.ts, 227, 5)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 231, 53)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 231, 70)) +>values : Symbol(values, Decl(iteratorZip.ts, 231, 81)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const hiddenInputs = { values: [1, 2], label: "inputs" }; +>hiddenInputs : Symbol(hiddenInputs, Decl(iteratorZip.ts, 233, 5)) +>values : Symbol(values, Decl(iteratorZip.ts, 233, 22)) +>label : Symbol(label, Decl(iteratorZip.ts, 233, 38)) + +Object.defineProperty(hiddenInputs, "label", { enumerable: false }); +>Object.defineProperty : Symbol(ObjectConstructor.defineProperty, Decl(lib.es5.d.ts, --, --)) +>Object : Symbol(Object, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>defineProperty : Symbol(ObjectConstructor.defineProperty, Decl(lib.es5.d.ts, --, --)) +>hiddenInputs : Symbol(hiddenInputs, Decl(iteratorZip.ts, 233, 5)) +>enumerable : Symbol(enumerable, Decl(iteratorZip.ts, 234, 46)) + +const nonEnumerable = Iterator.zipKeyed(hiddenInputs).toArray(); +>nonEnumerable : Symbol(nonEnumerable, Decl(iteratorZip.ts, 235, 5)) +>Iterator.zipKeyed(hiddenInputs).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>hiddenInputs : Symbol(hiddenInputs, Decl(iteratorZip.ts, 233, 5)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const nonEnumerablePadded = Iterator.zipKeyed(hiddenInputs, { mode: "longest", padding: { values: 0 } }).toArray(); +>nonEnumerablePadded : Symbol(nonEnumerablePadded, Decl(iteratorZip.ts, 236, 5)) +>Iterator.zipKeyed(hiddenInputs, { mode: "longest", padding: { values: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>hiddenInputs : Symbol(hiddenInputs, Decl(iteratorZip.ts, 233, 5)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 236, 61)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 236, 78)) +>values : Symbol(values, Decl(iteratorZip.ts, 236, 89)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +// The same static shape can have an enumerable non-iterator property instead. +// Such inputs are accepted by the fallback and checked at runtime. +const enumerableInputs = { values: [1, 2], label: "inputs" }; +>enumerableInputs : Symbol(enumerableInputs, Decl(iteratorZip.ts, 240, 5)) +>values : Symbol(values, Decl(iteratorZip.ts, 240, 26)) +>label : Symbol(label, Decl(iteratorZip.ts, 240, 42)) + +const enumerable = Iterator.zipKeyed(enumerableInputs).toArray(); +>enumerable : Symbol(enumerable, Decl(iteratorZip.ts, 241, 5)) +>Iterator.zipKeyed(enumerableInputs).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>enumerableInputs : Symbol(enumerableInputs, Decl(iteratorZip.ts, 240, 5)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +// The array's length and methods are not enumerable own properties. +const arrayInputs = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); +>arrayInputs : Symbol(arrayInputs, Decl(iteratorZip.ts, 244, 5)) +>Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +// The fallback must not claim that ignored properties exist on yielded objects. +const inheritedLabel: string = inherited[0].label; +>inheritedLabel : Symbol(inheritedLabel, Decl(iteratorZip.ts, 247, 5)) +>inherited : Symbol(inherited, Decl(iteratorZip.ts, 228, 5)) + +const nonEnumerableLabel: string = nonEnumerable[0].label; +>nonEnumerableLabel : Symbol(nonEnumerableLabel, Decl(iteratorZip.ts, 248, 5)) +>nonEnumerable : Symbol(nonEnumerable, Decl(iteratorZip.ts, 235, 5)) + +// Precise record inference still handles symbol keys and padding. +declare const ownKey: unique symbol; +>ownKey : Symbol(ownKey, Decl(iteratorZip.ts, 251, 13)) + +const precise: { values: number; [ownKey]: string; }[] = Iterator.zipKeyed({ values: [1], [ownKey]: ["a"] }).toArray(); +>precise : Symbol(precise, Decl(iteratorZip.ts, 252, 5)) +>values : Symbol(values, Decl(iteratorZip.ts, 252, 16)) +>[ownKey] : Symbol([ownKey], Decl(iteratorZip.ts, 252, 32)) +>ownKey : Symbol(ownKey, Decl(iteratorZip.ts, 251, 13)) +>Iterator.zipKeyed({ values: [1], [ownKey]: ["a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>values : Symbol(values, Decl(iteratorZip.ts, 252, 76)) +>[ownKey] : Symbol([ownKey], Decl(iteratorZip.ts, 252, 89)) +>ownKey : Symbol(ownKey, Decl(iteratorZip.ts, 251, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const preciseLongest: { values: number | undefined; }[] = Iterator.zipKeyed({ values: [1] }, { mode: "longest" }).toArray(); +>preciseLongest : Symbol(preciseLongest, Decl(iteratorZip.ts, 253, 5)) +>values : Symbol(values, Decl(iteratorZip.ts, 253, 23)) +>Iterator.zipKeyed({ values: [1] }, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>values : Symbol(values, Decl(iteratorZip.ts, 253, 77)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 253, 94)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const precisePadded: { values: number; }[] = Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: 0 } }).toArray(); +>precisePadded : Symbol(precisePadded, Decl(iteratorZip.ts, 254, 5)) +>values : Symbol(values, Decl(iteratorZip.ts, 254, 22)) +>Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>values : Symbol(values, Decl(iteratorZip.ts, 254, 64)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 254, 81)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 254, 98)) +>values : Symbol(values, Decl(iteratorZip.ts, 254, 109)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const emptyOwnProperties: never[] = Iterator.zipKeyed({}).toArray(); +>emptyOwnProperties : Symbol(emptyOwnProperties, Decl(iteratorZip.ts, 255, 5)) +>Iterator.zipKeyed({}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +Iterator.zipKeyed(0); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) + +Iterator.zipKeyed(null); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) + +Iterator.zipKeyed(instance, { mode: "invalid" }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>instance : Symbol(instance, Decl(iteratorZip.ts, 227, 5)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 259, 29)) + +Iterator.zipKeyed(instance, { mode: "shortest", padding: {} }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>instance : Symbol(instance, Decl(iteratorZip.ts, 227, 5)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 260, 29)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 260, 47)) + +Iterator.zipKeyed(instance, { mode: "longest", padding: 0 }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>instance : Symbol(instance, Decl(iteratorZip.ts, 227, 5)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 261, 29)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 261, 46)) + +Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: "invalid" } }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>values : Symbol(values, Decl(iteratorZip.ts, 262, 19)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 262, 36)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 262, 53)) +>values : Symbol(values, Decl(iteratorZip.ts, 262, 64)) + diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).types b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).types new file mode 100644 index 0000000000000..933da5476e72d --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).types @@ -0,0 +1,1939 @@ +//// [tests/cases/compiler/iteratorZip.ts] //// + +=== iteratorZip.ts === +declare const key: unique symbol; +>key : unique symbol + +const tuples: [number, string][] = Iterator.zip([ +>tuples : [number, string][] +>Iterator.zip([ [1, 2], new Set(["a", "b"]),] as const).toArray() : [1 | 2, string][] +>Iterator.zip([ [1, 2], new Set(["a", "b"]),] as const).toArray : () => [1 | 2, string][] +>Iterator.zip([ [1, 2], new Set(["a", "b"]),] as const) : IteratorObject<[1 | 2, string], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[ [1, 2], new Set(["a", "b"]),] as const : [readonly [1, 2], Set] +>[ [1, 2], new Set(["a", "b"]),] : [readonly [1, 2], Set] + + [1, 2], +>[1, 2] : readonly [1, 2] +>1 : 1 +>2 : 2 + + new Set(["a", "b"]), +>new Set(["a", "b"]) : Set +>Set : SetConstructor +>["a", "b"] : string[] +>"a" : "a" +>"b" : "b" + +] as const).toArray(); +>toArray : () => [1 | 2, string][] + +tuples[0][0] = 2; +>tuples[0][0] = 2 : 2 +>tuples[0][0] : number +>tuples[0] : [number, string] +>tuples : [number, string][] +>0 : 0 +>0 : 0 +>2 : 2 + +const shortestTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray(); +>shortestTuples : [number, string][] +>Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray() : [1, "a"][] +>Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray : () => [1, "a"][] +>Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }) : IteratorObject<[1, "a"], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] as const : [readonly [1], readonly ["a"]] +>[[1], ["a"]] : [readonly [1], readonly ["a"]] +>[1] : readonly [1] +>1 : 1 +>["a"] : readonly ["a"] +>"a" : "a" +>{ mode: "shortest" } : { mode: "shortest"; } +>mode : "shortest" +>"shortest" : "shortest" +>toArray : () => [1, "a"][] + +const strictTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray(); +>strictTuples : [number, string][] +>Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray() : [1, "a"][] +>Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray : () => [1, "a"][] +>Iterator.zip([[1], ["a"]] as const, { mode: "strict" }) : IteratorObject<[1, "a"], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] as const : [readonly [1], readonly ["a"]] +>[[1], ["a"]] : [readonly [1], readonly ["a"]] +>[1] : readonly [1] +>1 : 1 +>["a"] : readonly ["a"] +>"a" : "a" +>{ mode: "strict" } : { mode: "strict"; } +>mode : "strict" +>"strict" : "strict" +>toArray : () => [1, "a"][] + +const longestTuplesWithPadding: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray(); +>longestTuplesWithPadding : [number, string][] +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray() : [number, string][] +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray : () => [number, string][] +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }) : IteratorObject<[number, string], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] as const : [readonly [1], readonly ["a"]] +>[[1], ["a"]] : [readonly [1], readonly ["a"]] +>[1] : readonly [1] +>1 : 1 +>["a"] : readonly ["a"] +>"a" : "a" +>{ mode: "longest", padding: [1, "a"] } : { mode: "longest"; padding: [1, "a"]; } +>mode : "longest" +>"longest" : "longest" +>padding : [1, "a"] +>[1, "a"] : [1, "a"] +>1 : 1 +>"a" : "a" +>toArray : () => [number, string][] + +const longestTuplesWithoutPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray(); +>longestTuplesWithoutPadding : [number | undefined, string | undefined][] +>Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray() : [1 | undefined, "a" | undefined][] +>Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray : () => [1 | undefined, "a" | undefined][] +>Iterator.zip([[1], ["a"]] as const, { mode: "longest" }) : IteratorObject<[1 | undefined, "a" | undefined], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] as const : [readonly [1], readonly ["a"]] +>[[1], ["a"]] : [readonly [1], readonly ["a"]] +>[1] : readonly [1] +>1 : 1 +>["a"] : readonly ["a"] +>"a" : "a" +>{ mode: "longest" } : { mode: "longest"; } +>mode : "longest" +>"longest" : "longest" +>toArray : () => [1 | undefined, "a" | undefined][] + +const longestTuplesWithPartialPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray(); +>longestTuplesWithPartialPadding : [number | undefined, string | undefined][] +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray() : [number, "a" | undefined][] +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray : () => [number, "a" | undefined][] +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }) : IteratorObject<[number, "a" | undefined], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] as const : [readonly [1], readonly ["a"]] +>[[1], ["a"]] : [readonly [1], readonly ["a"]] +>[1] : readonly [1] +>1 : 1 +>["a"] : readonly ["a"] +>"a" : "a" +>{ mode: "longest", padding: [1] } : { mode: "longest"; padding: [1]; } +>mode : "longest" +>"longest" : "longest" +>padding : [1] +>[1] : [1] +>1 : 1 +>toArray : () => [number, "a" | undefined][] + +declare const maybeLongestOptions: { mode: "shortest"; } | { mode: "longest"; }; +>maybeLongestOptions : { mode: "shortest"; } | { mode: "longest"; } +>mode : "shortest" +>mode : "longest" + +const maybeLongestTuples: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray(); +>maybeLongestTuples : [number | undefined, string | undefined][] +>Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray() : [1 | undefined, "a" | undefined][] +>Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray : () => [1 | undefined, "a" | undefined][] +>Iterator.zip([[1], ["a"]] as const, maybeLongestOptions) : IteratorObject<[1 | undefined, "a" | undefined], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] as const : [readonly [1], readonly ["a"]] +>[[1], ["a"]] : [readonly [1], readonly ["a"]] +>[1] : readonly [1] +>1 : 1 +>["a"] : readonly ["a"] +>"a" : "a" +>maybeLongestOptions : { mode: "shortest"; } | { mode: "longest"; } +>toArray : () => [1 | undefined, "a" | undefined][] + +const empty: never[] = Iterator.zip([]).toArray(); +>empty : never[] +>Iterator.zip([]).toArray() : never[] +>Iterator.zip([]).toArray : () => never[] +>Iterator.zip([]) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[] : [] +>toArray : () => never[] + +const emptyLongest: never[] = Iterator.zip([], { mode: "longest" }).toArray(); +>emptyLongest : never[] +>Iterator.zip([], { mode: "longest" }).toArray() : never[] +>Iterator.zip([], { mode: "longest" }).toArray : () => never[] +>Iterator.zip([], { mode: "longest" }) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[] : [] +>{ mode: "longest" } : { mode: "longest"; } +>mode : "longest" +>"longest" : "longest" +>toArray : () => never[] + +declare const iterables: Iterable>; +>iterables : Iterable> + +const arrays: number[][] = Iterator.zip(iterables).toArray(); +>arrays : number[][] +>Iterator.zip(iterables).toArray() : number[][] +>Iterator.zip(iterables).toArray : () => number[][] +>Iterator.zip(iterables) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>iterables : Iterable> +>toArray : () => number[][] + +const longestArrays: (number | undefined)[][] = Iterator.zip(iterables, { mode: "longest" }).toArray(); +>longestArrays : (number | undefined)[][] +>Iterator.zip(iterables, { mode: "longest" }).toArray() : (number | undefined)[][] +>Iterator.zip(iterables, { mode: "longest" }).toArray : () => (number | undefined)[][] +>Iterator.zip(iterables, { mode: "longest" }) : IteratorObject<(number | undefined)[], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>iterables : Iterable> +>{ mode: "longest" } : { mode: "longest"; } +>mode : "longest" +>"longest" : "longest" +>toArray : () => (number | undefined)[][] + +const maybeLongestArrays: (number | undefined)[][] = Iterator.zip(iterables, maybeLongestOptions).toArray(); +>maybeLongestArrays : (number | undefined)[][] +>Iterator.zip(iterables, maybeLongestOptions).toArray() : (number | undefined)[][] +>Iterator.zip(iterables, maybeLongestOptions).toArray : () => (number | undefined)[][] +>Iterator.zip(iterables, maybeLongestOptions) : IteratorObject<(number | undefined)[], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>iterables : Iterable> +>maybeLongestOptions : { mode: "shortest"; } | { mode: "longest"; } +>toArray : () => (number | undefined)[][] + +declare const iterableArray: Iterable[]; +>iterableArray : Iterable[] + +const longestArrayWithPadding: (number | undefined)[][] = Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray(); +>longestArrayWithPadding : (number | undefined)[][] +>Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray() : (number | undefined)[][] +>Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray : () => (number | undefined)[][] +>Iterator.zip(iterableArray, { mode: "longest", padding: [] }) : IteratorObject<(number | undefined)[], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>iterableArray : Iterable[] +>{ mode: "longest", padding: [] } : { mode: "longest"; padding: []; } +>mode : "longest" +>"longest" : "longest" +>padding : [] +>[] : [] +>toArray : () => (number | undefined)[][] + +const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ +>objects : { a: number; b: string; [key]: boolean; }[] +>a : number +>b : string +>[key] : boolean +>key : unique symbol +>Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const).toArray() : { a: 1 | 2; b: string; [key]: boolean; }[] +>Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const).toArray : () => { a: 1 | 2; b: string; [key]: boolean; }[] +>Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const) : IteratorObject<{ a: 1 | 2; b: string; [key]: boolean; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const : { readonly a: readonly [1, 2]; readonly b: Set; readonly [key]: readonly [true, false]; } +>{ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} : { readonly a: readonly [1, 2]; readonly b: Set; readonly [key]: readonly [true, false]; } + + a: [1, 2], +>a : readonly [1, 2] +>[1, 2] : readonly [1, 2] +>1 : 1 +>2 : 2 + + b: new Set(["a", "b"]), +>b : Set +>new Set(["a", "b"]) : Set +>Set : SetConstructor +>["a", "b"] : string[] +>"a" : "a" +>"b" : "b" + + [key]: [true, false], +>[key] : readonly [true, false] +>key : unique symbol +>[true, false] : readonly [true, false] +>true : true +>false : false + +} as const).toArray(); +>toArray : () => { a: 1 | 2; b: string; [key]: boolean; }[] + +objects[0].a = 2; +>objects[0].a = 2 : 2 +>objects[0].a : number +>objects[0] : { a: number; b: string; [key]: boolean; } +>objects : { a: number; b: string; [key]: boolean; }[] +>0 : 0 +>a : number +>2 : 2 + +const longestObjectsWithPadding: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +>longestObjectsWithPadding : { a: number; b: string; }[] +>a : number +>b : string +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}).toArray() : { a: number; b: string; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}).toArray : () => { a: number; b: string; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}) : IteratorObject<{ a: number; b: string; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } +>{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } +>a : readonly [1] +>[1] : readonly [1] +>1 : 1 +>b : readonly ["a"] +>["a"] : readonly ["a"] +>"a" : "a" +>{ mode: "longest", padding: { a: 1, b: "a" },} : { mode: "longest"; padding: { a: 1; b: "a"; }; } + + mode: "longest", +>mode : "longest" +>"longest" : "longest" + + padding: { a: 1, b: "a" }, +>padding : { a: 1; b: "a"; } +>{ a: 1, b: "a" } : { a: 1; b: "a"; } +>a : 1 +>1 : 1 +>b : "a" +>"a" : "a" + +}).toArray(); +>toArray : () => { a: number; b: string; }[] + +const longestObjectsWithoutPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +>longestObjectsWithoutPadding : { a: number | undefined; b: string | undefined; }[] +>a : number | undefined +>b : string | undefined +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}).toArray() : { a: 1 | undefined; b: "a" | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}).toArray : () => { a: 1 | undefined; b: "a" | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}) : IteratorObject<{ a: 1 | undefined; b: "a" | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } +>{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } +>a : readonly [1] +>[1] : readonly [1] +>1 : 1 +>b : readonly ["a"] +>["a"] : readonly ["a"] +>"a" : "a" +>{ mode: "longest",} : { mode: "longest"; } + + mode: "longest", +>mode : "longest" +>"longest" : "longest" + +}).toArray(); +>toArray : () => { a: 1 | undefined; b: "a" | undefined; }[] + +const longestObjectsWithPartialPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +>longestObjectsWithPartialPadding : { a: number | undefined; b: string | undefined; }[] +>a : number | undefined +>b : string | undefined +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}).toArray() : { a: 1 | undefined; b: string; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}).toArray : () => { a: 1 | undefined; b: string; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}) : IteratorObject<{ a: 1 | undefined; b: string; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } +>{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } +>a : readonly [1] +>[1] : readonly [1] +>1 : 1 +>b : readonly ["a"] +>["a"] : readonly ["a"] +>"a" : "a" +>{ mode: "longest", padding: { b: "a" },} : { mode: "longest"; padding: { b: "a"; }; } + + mode: "longest", +>mode : "longest" +>"longest" : "longest" + + padding: { b: "a" }, +>padding : { b: "a"; } +>{ b: "a" } : { b: "a"; } +>b : "a" +>"a" : "a" + +}).toArray(); +>toArray : () => { a: 1 | undefined; b: string; }[] + +const maybeLongestObjects: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray(); +>maybeLongestObjects : { a: number | undefined; b: string | undefined; }[] +>a : number | undefined +>b : string | undefined +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray() : { a: 1 | undefined; b: "a" | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray : () => { a: 1 | undefined; b: "a" | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions) : IteratorObject<{ a: 1 | undefined; b: "a" | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } +>{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } +>a : readonly [1] +>[1] : readonly [1] +>1 : 1 +>b : readonly ["a"] +>["a"] : readonly ["a"] +>"a" : "a" +>maybeLongestOptions : { mode: "shortest"; } | { mode: "longest"; } +>toArray : () => { a: 1 | undefined; b: "a" | undefined; }[] + +interface Inputs { + a: Iterable; +>a : Iterable + + b: Iterator; +>b : Iterator +} + +declare const inputs: Inputs; +>inputs : Inputs + +const rows: { a: number; b: string; }[] = Iterator.zipKeyed(inputs).toArray(); +>rows : { a: number; b: string; }[] +>a : number +>b : string +>Iterator.zipKeyed(inputs).toArray() : { a: number; b: string; }[] +>Iterator.zipKeyed(inputs).toArray : () => { a: number; b: string; }[] +>Iterator.zipKeyed(inputs) : IteratorObject<{ a: number; b: string; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>inputs : Inputs +>toArray : () => { a: number; b: string; }[] + +Iterator.zip([[1]], { mode: "invalid" }); +>Iterator.zip([[1]], { mode: "invalid" }) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1]] : [number[]] +>[1] : number[] +>1 : 1 +>{ mode: "invalid" } : { mode: "invalid"; } +>mode : "invalid" +>"invalid" : "invalid" + +Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }); +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] as const : readonly [readonly [1], readonly ["a"]] +>[[1], ["a"]] : readonly [readonly [1], readonly ["a"]] +>[1] : readonly [1] +>1 : 1 +>["a"] : readonly ["a"] +>"a" : "a" +>{ mode: "longest", padding: [true] } : { mode: "longest"; padding: boolean[]; } +>mode : "longest" +>"longest" : "longest" +>padding : boolean[] +>[true] : boolean[] +>true : true + +Iterator.zip([[1]], { mode: "shortest", padding: [1] }); +>Iterator.zip([[1]], { mode: "shortest", padding: [1] }) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1]] : [number[]] +>[1] : number[] +>1 : 1 +>{ mode: "shortest", padding: [1] } : { mode: "shortest"; padding: number[]; } +>mode : "shortest" +>"shortest" : "shortest" +>padding : number[] +>[1] : number[] +>1 : 1 + +Iterator.zip(0); +>Iterator.zip(0) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>0 : 0 + +Iterator.zipKeyed({ a: 0 }); +>Iterator.zipKeyed({ a: 0 }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: 0 } : { a: number; } +>a : number +>0 : 0 + +const emptyKeyed: never[] = Iterator.zipKeyed({}).toArray(); +>emptyKeyed : never[] +>Iterator.zipKeyed({}).toArray() : never[] +>Iterator.zipKeyed({}).toArray : () => never[] +>Iterator.zipKeyed({}) : IteratorObject +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{} : {} +>toArray : () => never[] + +const emptyKeyedLongest: never[] = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); +>emptyKeyedLongest : never[] +>Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray() : never[] +>Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray : () => never[] +>Iterator.zipKeyed({}, { mode: "longest", padding: {} }) : IteratorObject +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{} : {} +>{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } +>mode : "longest" +>"longest" : "longest" +>padding : {} +>{} : {} +>toArray : () => never[] + +declare const unionInputs: { a: Iterable; } | { b: Iterator; }; +>unionInputs : { a: Iterable; } | { b: Iterator; } +>a : Iterable +>b : Iterator + +const unionRows: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(unionInputs).toArray(); +>unionRows : ({ a: number; } | { b: string; })[] +>a : number +>b : string +>Iterator.zipKeyed(unionInputs).toArray() : ({ a: number; } | { b: string; })[] +>Iterator.zipKeyed(unionInputs).toArray : () => ({ a: number; } | { b: string; })[] +>Iterator.zipKeyed(unionInputs) : IteratorObject<{ a: number; } | { b: string; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>unionInputs : { a: Iterable; } | { b: Iterator; } +>toArray : () => ({ a: number; } | { b: string; })[] + +// Inputs + +Iterator.zip("ab"); +>Iterator.zip("ab") : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>"ab" : "ab" + +Iterator.zip(["ab"]); +>Iterator.zip(["ab"]) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>["ab"] : [string] +>"ab" : "ab" + +Iterator.zip(new Set(["ab"])); +>Iterator.zip(new Set(["ab"])) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>new Set(["ab"]) : Set +>Set : SetConstructor +>["ab"] : string[] +>"ab" : "ab" + +Iterator.zipKeyed("ab"); +>Iterator.zipKeyed("ab") : IteratorObject +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>"ab" : "ab" + +Iterator.zipKeyed({ a: "ab" }); +>Iterator.zipKeyed({ a: "ab" }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: "ab" } : { a: string; } +>a : string +>"ab" : "ab" + +Iterator.zip([], { mode: "longest", padding: "ab" }); +>Iterator.zip([], { mode: "longest", padding: "ab" }) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[] : [] +>{ mode: "longest", padding: "ab" } : { mode: "longest"; padding: string; } +>mode : "longest" +>"longest" : "longest" +>padding : string +>"ab" : "ab" + +Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); +>Iterator.zip([["a"]], { mode: "longest", padding: "ab" }) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[["a"]] : [string[]] +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: "ab" } : { mode: "longest"; padding: string; } +>mode : "longest" +>"longest" : "longest" +>padding : string +>"ab" : "ab" + +Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); +>Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }) : IteratorObject +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{} : {} +>{ mode: "longest", padding: "ab" } : { mode: "longest"; padding: string; } +>mode : "longest" +>"longest" : "longest" +>padding : string +>"ab" : "ab" + +const a: [string][] = Iterator.zip([new String("ab")]).toArray(); +>a : [string][] +>Iterator.zip([new String("ab")]).toArray() : [string][] +>Iterator.zip([new String("ab")]).toArray : () => [string][] +>Iterator.zip([new String("ab")]) : IteratorObject<[string], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[new String("ab")] : [String] +>new String("ab") : String +>String : StringConstructor +>"ab" : "ab" +>toArray : () => [string][] + +const b: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); +>b : { a: string; }[] +>a : string +>Iterator.zipKeyed({ a: new String("ab") }).toArray() : { a: string; }[] +>Iterator.zipKeyed({ a: new String("ab") }).toArray : () => { a: string; }[] +>Iterator.zipKeyed({ a: new String("ab") }) : IteratorObject<{ a: string; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: new String("ab") } : { a: String; } +>a : String +>new String("ab") : String +>String : StringConstructor +>"ab" : "ab" +>toArray : () => { a: string; }[] + +const c: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); +>c : (string | undefined)[][] +>Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray() : (string | undefined)[][] +>Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray : () => (string | undefined)[][] +>Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }) : IteratorObject<(string | undefined)[], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[["a"]] : string[][] +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: new String("ab") } : { mode: "longest"; padding: String; } +>mode : "longest" +>"longest" : "longest" +>padding : String +>new String("ab") : String +>String : StringConstructor +>"ab" : "ab" +>toArray : () => (string | undefined)[][] + +const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); +>d : { a: number; }[] +>Iterator.zipKeyed({ a: [1], b: undefined }).toArray() : { a: number; }[] +>Iterator.zipKeyed({ a: [1], b: undefined }).toArray : () => { a: number; }[] +>Iterator.zipKeyed({ a: [1], b: undefined }) : IteratorObject<{ a: number; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1], b: undefined } : { a: number[]; b: undefined; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : undefined +>undefined : undefined +>toArray : () => { a: number; }[] + +const e: { a: number; }[] = d; +>e : { a: number; }[] +>a : number +>d : { a: number; }[] + +d[0].b; +>d[0].b : any +>d[0] : { a: number; } +>d : { a: number; }[] +>0 : 0 +>b : any + +const f: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); +>f : never[] +>Iterator.zipKeyed({ a: undefined }).toArray() : never[] +>Iterator.zipKeyed({ a: undefined }).toArray : () => never[] +>Iterator.zipKeyed({ a: undefined }) : IteratorObject +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: undefined } : { a: undefined; } +>a : undefined +>undefined : undefined +>toArray : () => never[] + +const g: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); +>g : never[] +>Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray() : never[] +>Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray : () => never[] +>Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }) : IteratorObject +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: undefined } : { a: undefined; } +>a : undefined +>undefined : undefined +>{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } +>mode : "longest" +>"longest" : "longest" +>padding : {} +>{} : {} +>toArray : () => never[] + +interface I { + readonly a: Iterable; +>a : Iterable + + readonly b?: Iterator; +>b : Iterator | undefined + + readonly c: Iterable | undefined; +>c : Iterable | undefined + + readonly d?: undefined; +>d : undefined +} +declare const h: I; +>h : I + +const i = Iterator.zipKeyed(h).toArray(); +>i : { a: number; b?: string | undefined; c?: boolean | undefined; }[] +>Iterator.zipKeyed(h).toArray() : { a: number; b?: string | undefined; c?: boolean | undefined; }[] +>Iterator.zipKeyed(h).toArray : () => { a: number; b?: string | undefined; c?: boolean | undefined; }[] +>Iterator.zipKeyed(h) : IteratorObject<{ a: number; b?: string | undefined; c?: boolean | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>h : I +>toArray : () => { a: number; b?: string | undefined; c?: boolean | undefined; }[] + +const j: { a: number; b?: string; c?: boolean; }[] = i; +>j : { a: number; b?: string; c?: boolean; }[] +>a : number +>b : string | undefined +>c : boolean | undefined +>i : { a: number; b?: string | undefined; c?: boolean | undefined; }[] + +i[0].a = 2; +>i[0].a = 2 : 2 +>i[0].a : number +>i[0] : { a: number; b?: string | undefined; c?: boolean | undefined; } +>i : { a: number; b?: string | undefined; c?: boolean | undefined; }[] +>0 : 0 +>a : number +>2 : 2 + +i[0].b = "a"; +>i[0].b = "a" : "a" +>i[0].b : string | undefined +>i[0] : { a: number; b?: string | undefined; c?: boolean | undefined; } +>i : { a: number; b?: string | undefined; c?: boolean | undefined; }[] +>0 : 0 +>b : string | undefined +>"a" : "a" + +i[0].c = true; +>i[0].c = true : true +>i[0].c : boolean | undefined +>i[0] : { a: number; b?: string | undefined; c?: boolean | undefined; } +>i : { a: number; b?: string | undefined; c?: boolean | undefined; }[] +>0 : 0 +>c : boolean | undefined +>true : true + +i[0].d; +>i[0].d : any +>i[0] : { a: number; b?: string | undefined; c?: boolean | undefined; } +>i : { a: number; b?: string | undefined; c?: boolean | undefined; }[] +>0 : 0 +>d : any + +const k: { a: number; c: boolean; }[] = i; +>k : { a: number; c: boolean; }[] +>a : number +>c : boolean +>i : { a: number; b?: string | undefined; c?: boolean | undefined; }[] + +const l: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); +>l : { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] +>a : number | undefined +>b : string | undefined +>c : boolean | undefined +>Iterator.zipKeyed(h, { mode: "longest" }).toArray() : { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] +>Iterator.zipKeyed(h, { mode: "longest" }).toArray : () => { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] +>Iterator.zipKeyed(h, { mode: "longest" }) : IteratorObject<{ a: number | undefined; b?: string | undefined; c?: boolean | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>h : I +>{ mode: "longest" } : { mode: "longest"; } +>mode : "longest" +>"longest" : "longest" +>toArray : () => { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] + +declare const m: { a: Iterable; } | { b: Iterator; }; +>m : { a: Iterable; } | { b: Iterator; } +>a : Iterable +>b : Iterator + +const n: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(m).toArray(); +>n : ({ a: number; } | { b: string; })[] +>a : number +>b : string +>Iterator.zipKeyed(m).toArray() : ({ a: number; } | { b: string; })[] +>Iterator.zipKeyed(m).toArray : () => ({ a: number; } | { b: string; })[] +>Iterator.zipKeyed(m) : IteratorObject<{ a: number; } | { b: string; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>m : { a: Iterable; } | { b: Iterator; } +>toArray : () => ({ a: number; } | { b: string; })[] + +declare const o: { a: Iterable; } | { b: number; }; +>o : { a: Iterable; } | { b: number; } +>a : Iterable +>b : number + +Iterator.zipKeyed(o); +>Iterator.zipKeyed(o) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>o : { a: Iterable; } | { b: number; } + +Iterator.zipKeyed(o, { mode: "longest" }); +>Iterator.zipKeyed(o, { mode: "longest" }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>o : { a: Iterable; } | { b: number; } +>{ mode: "longest" } : { mode: "longest"; } +>mode : "longest" +>"longest" : "longest" + +Iterator.zipKeyed(o, { mode: "longest", padding: {} }); +>Iterator.zipKeyed(o, { mode: "longest", padding: {} }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>o : { a: Iterable; } | { b: number; } +>{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } +>mode : "longest" +>"longest" : "longest" +>padding : {} +>{} : {} + +declare const p: { a?: Iterable; } | { b: string; }; +>p : { a?: Iterable; } | { b: string; } +>a : Iterable | undefined +>b : string + +Iterator.zipKeyed(p); +>Iterator.zipKeyed(p) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>p : { a?: Iterable; } | { b: string; } + +declare const q: { a: Iterable; } | { b: undefined; }; +>q : { a: Iterable; } | { b: undefined; } +>a : Iterable +>b : undefined + +const r: { a: number; }[] = Iterator.zipKeyed(q).toArray(); +>r : { a: number; }[] +>a : number +>Iterator.zipKeyed(q).toArray() : { a: number; }[] +>Iterator.zipKeyed(q).toArray : () => { a: number; }[] +>Iterator.zipKeyed(q) : IteratorObject<{ a: number; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>q : { a: Iterable; } | { b: undefined; } +>toArray : () => { a: number; }[] + +declare const s: unique symbol; +>s : unique symbol + +declare const t: { a: Iterable; [s]?: Iterable; }; +>t : { a: Iterable; [s]?: Iterable; } +>a : Iterable +>[s] : Iterable | undefined +>s : unique symbol + +const u: { a: number; [s]?: string; }[] = Iterator.zipKeyed(t).toArray(); +>u : { a: number; [s]?: string; }[] +>a : number +>[s] : string | undefined +>s : unique symbol +>Iterator.zipKeyed(t).toArray() : { a: number; [s]?: string | undefined; }[] +>Iterator.zipKeyed(t).toArray : () => { a: number; [s]?: string | undefined; }[] +>Iterator.zipKeyed(t) : IteratorObject<{ a: number; [s]?: string | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>t : { a: Iterable; [s]?: Iterable; } +>toArray : () => { a: number; [s]?: string | undefined; }[] + +Iterator.zipKeyed({ a: [1], b: null }); +>Iterator.zipKeyed({ a: [1], b: null }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1], b: null } : { a: number[]; b: null; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : null + +Iterator.zipKeyed({ a: [1], b: false }); +>Iterator.zipKeyed({ a: [1], b: false }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1], b: false } : { a: number[]; b: false; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : false +>false : false + +Iterator.zip([undefined]); +>Iterator.zip([undefined]) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[undefined] : [undefined] +>undefined : undefined + +declare const v: { a?: undefined; }; +>v : { a?: undefined; } +>a : undefined + +const w: never[] = Iterator.zipKeyed(v).toArray(); +>w : never[] +>Iterator.zipKeyed(v).toArray() : never[] +>Iterator.zipKeyed(v).toArray : () => never[] +>Iterator.zipKeyed(v) : IteratorObject +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>v : { a?: undefined; } +>toArray : () => never[] + +const x: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); +>x : { a: number; }[] +>a : number +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray() : { a: number; }[] +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray : () => { a: number; }[] +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }) : IteratorObject<{ a: number; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1], b: undefined } : { a: number[]; b: undefined; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : undefined +>undefined : undefined +>{ mode: "longest", padding: { a: 0 } } : { mode: "longest"; padding: { a: number; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: number; } +>{ a: 0 } : { a: number; } +>a : number +>0 : 0 +>toArray : () => { a: number; }[] + +const y: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); +>y : { a: number | undefined; }[] +>a : number | undefined +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray() : { a: number | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray : () => { a: number | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }) : IteratorObject<{ a: number | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1], b: undefined } : { a: number[]; b: undefined; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : undefined +>undefined : undefined +>{ mode: "longest" } : { mode: "longest"; } +>mode : "longest" +>"longest" : "longest" +>toArray : () => { a: number | undefined; }[] + +function f1(a: Iterable) { +>f1 : (a: Iterable) => { b: { a: T; }[]; c: [T][]; } +>a : Iterable + + const b: { a: T; }[] = Iterator.zipKeyed({ a }).toArray(); +>b : { a: T; }[] +>a : T +>Iterator.zipKeyed({ a }).toArray() : { a: T; }[] +>Iterator.zipKeyed({ a }).toArray : () => { a: T; }[] +>Iterator.zipKeyed({ a }) : IteratorObject<{ a: T; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K] | undefined; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K] | undefined; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K] | undefined; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K] | undefined; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K] | undefined; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K] | undefined; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a } : { a: Iterable; } +>a : Iterable +>toArray : () => { a: T; }[] + + const c: [T][] = Iterator.zip([a]).toArray(); +>c : [T][] +>Iterator.zip([a]).toArray() : [T][] +>Iterator.zip([a]).toArray : () => [T][] +>Iterator.zip([a]) : IteratorObject<[T], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T_1, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T_1, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T_1, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T_1 extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T_1 extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T_1, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T_1, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T_1, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T_1 extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T_1 extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[a] : [Iterable] +>a : Iterable +>toArray : () => [T][] + + return { b, c }; +>{ b, c } : { b: { a: T; }[]; c: [T][]; } +>b : { a: T; }[] +>c : [T][] +} + +// Padding + +const paddingA: [Iterable, ...Iterable[]] = [[1, 2], [3]]; +>paddingA : [Iterable, ...Iterable[]] +>[[1, 2], [3]] : [number[], number[]] +>[1, 2] : number[] +>1 : 1 +>2 : 2 +>[3] : number[] +>3 : 3 + +const paddingB = Iterator.zip(paddingA, { mode: "longest", padding: [0] }).toArray(); +>paddingB : [number, ...(number | undefined)[]][] +>Iterator.zip(paddingA, { mode: "longest", padding: [0] }).toArray() : [number, ...(number | undefined)[]][] +>Iterator.zip(paddingA, { mode: "longest", padding: [0] }).toArray : () => [number, ...(number | undefined)[]][] +>Iterator.zip(paddingA, { mode: "longest", padding: [0] }) : IteratorObject<[number, ...(number | undefined)[]], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>paddingA : [Iterable, ...Iterable[]] +>{ mode: "longest", padding: [0] } : { mode: "longest"; padding: [number]; } +>mode : "longest" +>"longest" : "longest" +>padding : [number] +>[0] : [number] +>0 : 0 +>toArray : () => [number, ...(number | undefined)[]][] + +const paddingC: (number | undefined)[][] = paddingB; +>paddingC : (number | undefined)[][] +>paddingB : [number, ...(number | undefined)[]][] + +const paddingD: number[][] = paddingB; +>paddingD : number[][] +>paddingB : [number, ...(number | undefined)[]][] + +const paddingE: Record> = { a: [1], b: [2, 3] }; +>paddingE : Record> +>{ a: [1], b: [2, 3] } : { a: number[]; b: number[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : number[] +>[2, 3] : number[] +>2 : 2 +>3 : 3 + +const paddingF = Iterator.zipKeyed(paddingE, { mode: "longest", padding: {} }).toArray(); +>paddingF : { [x: string]: number | undefined; }[] +>Iterator.zipKeyed(paddingE, { mode: "longest", padding: {} }).toArray() : { [x: string]: number | undefined; }[] +>Iterator.zipKeyed(paddingE, { mode: "longest", padding: {} }).toArray : () => { [x: string]: number | undefined; }[] +>Iterator.zipKeyed(paddingE, { mode: "longest", padding: {} }) : IteratorObject<{ [x: string]: number | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>paddingE : Record> +>{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } +>mode : "longest" +>"longest" : "longest" +>padding : {} +>{} : {} +>toArray : () => { [x: string]: number | undefined; }[] + +const paddingG: Record[] = paddingF; +>paddingG : Record[] +>paddingF : { [x: string]: number | undefined; }[] + +const paddingH: Record[] = paddingF; +>paddingH : Record[] +>paddingF : { [x: string]: number | undefined; }[] + +declare const paddingI: Record; +>paddingI : Record + +const paddingJ = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: paddingI }).toArray(); +>paddingJ : { a: number | undefined; b: number | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: paddingI }).toArray() : { a: number | undefined; b: number | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: paddingI }).toArray : () => { a: number | undefined; b: number | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: paddingI }) : IteratorObject<{ a: number | undefined; b: number | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1], b: [2, 3] } : { a: number[]; b: number[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : number[] +>[2, 3] : number[] +>2 : 2 +>3 : 3 +>{ mode: "longest", padding: paddingI } : { mode: "longest"; padding: Record; } +>mode : "longest" +>"longest" : "longest" +>padding : Record +>paddingI : Record +>toArray : () => { a: number | undefined; b: number | undefined; }[] + +const paddingK: { a: number | undefined; b: number | undefined; }[] = paddingJ; +>paddingK : { a: number | undefined; b: number | undefined; }[] +>a : number | undefined +>b : number | undefined +>paddingJ : { a: number | undefined; b: number | undefined; }[] + +const paddingL: { a: number; b: number; }[] = paddingJ; +>paddingL : { a: number; b: number; }[] +>a : number +>b : number +>paddingJ : { a: number | undefined; b: number | undefined; }[] + +const paddingM = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); +>paddingM : [number, string][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray() : [number, string][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray : () => [number, string][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }) : IteratorObject<[number, string], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] : [number[], string[]] +>[1] : number[] +>1 : 1 +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: [0, ""] } : { mode: "longest"; padding: [number, string]; } +>mode : "longest" +>"longest" : "longest" +>padding : [number, string] +>[0, ""] : [number, string] +>0 : 0 +>"" : "" +>toArray : () => [number, string][] + +const paddingN: [number, string][] = paddingM; +>paddingN : [number, string][] +>paddingM : [number, string][] + +const paddingO = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); +>paddingO : { a: number; b: string; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray() : { a: number; b: string; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray : () => { a: number; b: string; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }) : IteratorObject<{ a: number; b: string; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : string[] +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: { a: 0, b: "" } } : { mode: "longest"; padding: { a: number; b: string; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: number; b: string; } +>{ a: 0, b: "" } : { a: number; b: string; } +>a : number +>0 : 0 +>b : string +>"" : "" +>toArray : () => { a: number; b: string; }[] + +const paddingP: { a: number; b: string; }[] = paddingO; +>paddingP : { a: number; b: string; }[] +>a : number +>b : string +>paddingO : { a: number; b: string; }[] + +const paddingQ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); +>paddingQ : [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray() : [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray : () => [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }) : IteratorObject<[number, string | undefined], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] : [number[], string[]] +>[1] : number[] +>1 : 1 +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: [0] } : { mode: "longest"; padding: [number]; } +>mode : "longest" +>"longest" : "longest" +>padding : [number] +>[0] : [number] +>0 : 0 +>toArray : () => [number, string | undefined][] + +const paddingR: [number | undefined, string | undefined][] = paddingQ; +>paddingR : [number | undefined, string | undefined][] +>paddingQ : [number, string | undefined][] + +const paddingS: [number, string][] = paddingQ; +>paddingS : [number, string][] +>paddingQ : [number, string | undefined][] + +const paddingT = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); +>paddingT : { a: number; b: string | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray() : { a: number; b: string | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray : () => { a: number; b: string | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }) : IteratorObject<{ a: number; b: string | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : string[] +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: { a: 0 } } : { mode: "longest"; padding: { a: number; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: number; } +>{ a: 0 } : { a: number; } +>a : number +>0 : 0 +>toArray : () => { a: number; b: string | undefined; }[] + +const paddingU: { a: number | undefined; b: string | undefined; }[] = paddingT; +>paddingU : { a: number | undefined; b: string | undefined; }[] +>a : number | undefined +>b : string | undefined +>paddingT : { a: number; b: string | undefined; }[] + +const paddingV: { a: number; b: string; }[] = paddingT; +>paddingV : { a: number; b: string; }[] +>a : number +>b : string +>paddingT : { a: number; b: string | undefined; }[] + +declare const paddingW: readonly [number, string]; +>paddingW : readonly [number, string] + +const paddingX: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingW }).toArray(); +>paddingX : [number, string][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingW }).toArray() : [number, string][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingW }).toArray : () => [number, string][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingW }) : IteratorObject<[number, string], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] : [number[], string[]] +>[1] : number[] +>1 : 1 +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: paddingW } : { mode: "longest"; padding: readonly [number, string]; } +>mode : "longest" +>"longest" : "longest" +>padding : readonly [number, string] +>paddingW : readonly [number, string] +>toArray : () => [number, string][] + +declare const paddingY: [number, string?]; +>paddingY : [number, (string | undefined)?] + +const paddingZ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY }).toArray(); +>paddingZ : [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY }).toArray() : [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY }).toArray : () => [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY }) : IteratorObject<[number, string | undefined], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] : [number[], string[]] +>[1] : number[] +>1 : 1 +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: paddingY } : { mode: "longest"; padding: [number, (string | undefined)?]; } +>mode : "longest" +>"longest" : "longest" +>padding : [number, (string | undefined)?] +>paddingY : [number, (string | undefined)?] +>toArray : () => [number, string | undefined][] + +const paddingA1: [number, string][] = paddingZ; +>paddingA1 : [number, string][] +>paddingZ : [number, string | undefined][] + +declare const paddingB1: [Iterable] | [Iterable, Iterable]; +>paddingB1 : [Iterable] | [Iterable, Iterable] + +const paddingC1 = Iterator.zip(paddingB1, { mode: "longest", padding: [0] }).toArray(); +>paddingC1 : ([number] | [number, number | undefined])[] +>Iterator.zip(paddingB1, { mode: "longest", padding: [0] }).toArray() : ([number] | [number, number | undefined])[] +>Iterator.zip(paddingB1, { mode: "longest", padding: [0] }).toArray : () => ([number] | [number, number | undefined])[] +>Iterator.zip(paddingB1, { mode: "longest", padding: [0] }) : IteratorObject<[number] | [number, number | undefined], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>paddingB1 : [Iterable] | [Iterable, Iterable] +>{ mode: "longest", padding: [0] } : { mode: "longest"; padding: [number]; } +>mode : "longest" +>"longest" : "longest" +>padding : [number] +>[0] : [number] +>0 : 0 +>toArray : () => ([number] | [number, number | undefined])[] + +const paddingD1: number[][] = paddingC1; +>paddingD1 : number[][] +>paddingC1 : ([number] | [number, number | undefined])[] + +declare const paddingE1: { a: Iterable; } | { b: Iterable; }; +>paddingE1 : { a: Iterable; } | { b: Iterable; } +>a : Iterable +>b : Iterable + +const paddingF1 = Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: 0 } }).toArray(); +>paddingF1 : ({ a: number; } | { b: string | undefined; })[] +>Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: 0 } }).toArray() : ({ a: number; } | { b: string | undefined; })[] +>Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: 0 } }).toArray : () => ({ a: number; } | { b: string | undefined; })[] +>Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: 0 } }) : IteratorObject<{ a: number; } | { b: string | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>paddingE1 : { a: Iterable; } | { b: Iterable; } +>{ mode: "longest", padding: { a: 0 } } : { mode: "longest"; padding: { a: number; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: number; } +>{ a: 0 } : { a: number; } +>a : number +>0 : 0 +>toArray : () => ({ a: number; } | { b: string | undefined; })[] + +const paddingG1: ({ a: number; } | { b: string; })[] = paddingF1; +>paddingG1 : ({ a: number; } | { b: string; })[] +>a : number +>b : string +>paddingF1 : ({ a: number; } | { b: string | undefined; })[] + +declare const paddingH1: { a: number; } | { b: string; }; +>paddingH1 : { a: number; } | { b: string; } +>a : number +>b : string + +const paddingI1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: paddingH1 }).toArray(); +>paddingI1 : { a: number | undefined; b: string | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: paddingH1 }).toArray() : { a: number | undefined; b: string | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: paddingH1 }).toArray : () => { a: number | undefined; b: string | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: paddingH1 }) : IteratorObject<{ a: number | undefined; b: string | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : string[] +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: paddingH1 } : { mode: "longest"; padding: { a: number; } | { b: string; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: number; } | { b: string; } +>paddingH1 : { a: number; } | { b: string; } +>toArray : () => { a: number | undefined; b: string | undefined; }[] + +const paddingJ1: { a: number; b: string; }[] = paddingI1; +>paddingJ1 : { a: number; b: string; }[] +>a : number +>b : string +>paddingI1 : { a: number | undefined; b: string | undefined; }[] + +const paddingK1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); +>paddingK1 : { a: number | undefined; b: number; }[] +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray() : { a: number | undefined; b: number; }[] +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray : () => { a: number | undefined; b: number; }[] +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }) : IteratorObject<{ a: number | undefined; b: number; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1], b: [2] } : { a: number[]; b: number[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : number[] +>[2] : number[] +>2 : 2 +>{ mode: "longest", padding: { a: undefined, b: 0 } } : { mode: "longest"; padding: { a: undefined; b: number; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: undefined; b: number; } +>{ a: undefined, b: 0 } : { a: undefined; b: number; } +>a : undefined +>undefined : undefined +>b : number +>0 : 0 +>toArray : () => { a: number | undefined; b: number; }[] + +const paddingL1: { a: number; b: number; }[] = paddingK1; +>paddingL1 : { a: number; b: number; }[] +>a : number +>b : number +>paddingK1 : { a: number | undefined; b: number; }[] + +declare const paddingM1: { [K in `a${string}`]: Iterable; }; +>paddingM1 : { [x: `a${string}`]: Iterable; } + +const paddingN1 = Iterator.zipKeyed(paddingM1, { mode: "longest", padding: {} }).toArray(); +>paddingN1 : { [x: `a${string}`]: number | undefined; }[] +>Iterator.zipKeyed(paddingM1, { mode: "longest", padding: {} }).toArray() : { [x: `a${string}`]: number | undefined; }[] +>Iterator.zipKeyed(paddingM1, { mode: "longest", padding: {} }).toArray : () => { [x: `a${string}`]: number | undefined; }[] +>Iterator.zipKeyed(paddingM1, { mode: "longest", padding: {} }) : IteratorObject<{ [x: `a${string}`]: number | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>paddingM1 : { [x: `a${string}`]: Iterable; } +>{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } +>mode : "longest" +>"longest" : "longest" +>padding : {} +>{} : {} +>toArray : () => { [x: `a${string}`]: number | undefined; }[] + +const paddingO1: { [K in `a${string}`]: number; }[] = paddingN1; +>paddingO1 : { [x: `a${string}`]: number; }[] +>paddingN1 : { [x: `a${string}`]: number | undefined; }[] + +declare const paddingP1: unique symbol; +>paddingP1 : unique symbol + +const paddingQ1: { [paddingP1]: number; }[] = Iterator.zipKeyed({ [paddingP1]: [1] }, { mode: "longest", padding: { [paddingP1]: 0 } }).toArray(); +>paddingQ1 : { [paddingP1]: number; }[] +>[paddingP1] : number +>paddingP1 : unique symbol +>Iterator.zipKeyed({ [paddingP1]: [1] }, { mode: "longest", padding: { [paddingP1]: 0 } }).toArray() : { [paddingP1]: number; }[] +>Iterator.zipKeyed({ [paddingP1]: [1] }, { mode: "longest", padding: { [paddingP1]: 0 } }).toArray : () => { [paddingP1]: number; }[] +>Iterator.zipKeyed({ [paddingP1]: [1] }, { mode: "longest", padding: { [paddingP1]: 0 } }) : IteratorObject<{ [paddingP1]: number; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ [paddingP1]: [1] } : { [paddingP1]: number[]; } +>[paddingP1] : number[] +>paddingP1 : unique symbol +>[1] : number[] +>1 : 1 +>{ mode: "longest", padding: { [paddingP1]: 0 } } : { mode: "longest"; padding: { [paddingP1]: number; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { [paddingP1]: number; } +>{ [paddingP1]: 0 } : { [paddingP1]: number; } +>[paddingP1] : number +>paddingP1 : unique symbol +>0 : 0 +>toArray : () => { [paddingP1]: number; }[] + +declare const paddingR1: Record & { a: number; }; +>paddingR1 : Record & { a: number; } +>a : number + +const paddingS1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: paddingR1 }).toArray(); +>paddingS1 : { a: number; b: number | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: paddingR1 }).toArray() : { a: number; b: number | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: paddingR1 }).toArray : () => { a: number; b: number | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: paddingR1 }) : IteratorObject<{ a: number; b: number | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1], b: [2] } : { a: number[]; b: number[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : number[] +>[2] : number[] +>2 : 2 +>{ mode: "longest", padding: paddingR1 } : { mode: "longest"; padding: Record & { a: number; }; } +>mode : "longest" +>"longest" : "longest" +>padding : Record & { a: number; } +>paddingR1 : Record & { a: number; } +>toArray : () => { a: number; b: number | undefined; }[] + +const paddingT1: { a: number; b: number | undefined; }[] = paddingS1; +>paddingT1 : { a: number; b: number | undefined; }[] +>a : number +>b : number | undefined +>paddingS1 : { a: number; b: number | undefined; }[] + +const paddingU1: { a: number; b: number; }[] = paddingS1; +>paddingU1 : { a: number; b: number; }[] +>a : number +>b : number +>paddingS1 : { a: number; b: number | undefined; }[] + +declare const paddingV1: [number] | [number, string]; +>paddingV1 : [number] | [number, string] + +const paddingW1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingV1 }).toArray(); +>paddingW1 : [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingV1 }).toArray() : [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingV1 }).toArray : () => [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingV1 }) : IteratorObject<[number, string | undefined], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] : [number[], string[]] +>[1] : number[] +>1 : 1 +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: paddingV1 } : { mode: "longest"; padding: [number] | [number, string]; } +>mode : "longest" +>"longest" : "longest" +>padding : [number] | [number, string] +>paddingV1 : [number] | [number, string] +>toArray : () => [number, string | undefined][] + +const paddingX1: [number, string | undefined][] = paddingW1; +>paddingX1 : [number, string | undefined][] +>paddingW1 : [number, string | undefined][] + +const paddingY1: [number, string][] = paddingW1; +>paddingY1 : [number, string][] +>paddingW1 : [number, string | undefined][] + +const paddingZ1: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); +>paddingZ1 : [number | undefined, number][] +>Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray() : [number | undefined, number][] +>Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray : () => [number | undefined, number][] +>Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }) : IteratorObject<[number | undefined, number], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], [2]] : [number[], number[]] +>[1] : number[] +>1 : 1 +>[2] : number[] +>2 : 2 +>{ mode: "longest", padding: [undefined, 0] } : { mode: "longest"; padding: [undefined, number]; } +>mode : "longest" +>"longest" : "longest" +>padding : [undefined, number] +>[undefined, 0] : [undefined, number] +>undefined : undefined +>0 : 0 +>toArray : () => [number | undefined, number][] + +const paddingA2: { a: number | undefined; b: number; }[] = paddingK1; +>paddingA2 : { a: number | undefined; b: number; }[] +>a : number | undefined +>b : number +>paddingK1 : { a: number | undefined; b: number; }[] + +// Own properties + +class InputsWithPrototypeMembers { +>InputsWithPrototypeMembers : InputsWithPrototypeMembers + + values = [1, 2]; +>values : number[] +>[1, 2] : number[] +>1 : 1 +>2 : 2 + + get label() { +>label : string + + return "inputs"; +>"inputs" : "inputs" + } + + describe() { +>describe : () => string + + return this.label; +>this.label : string +>this : this +>label : string + } +} + +const instance = new InputsWithPrototypeMembers(); +>instance : InputsWithPrototypeMembers +>new InputsWithPrototypeMembers() : InputsWithPrototypeMembers +>InputsWithPrototypeMembers : typeof InputsWithPrototypeMembers + +const inherited = Iterator.zipKeyed(instance).toArray(); +>inherited : Record[] +>Iterator.zipKeyed(instance).toArray() : Record[] +>Iterator.zipKeyed(instance).toArray : () => Record[] +>Iterator.zipKeyed(instance) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>instance : InputsWithPrototypeMembers +>toArray : () => Record[] + +const inheritedStrict = Iterator.zipKeyed(instance, { mode: "strict" }).toArray(); +>inheritedStrict : Record[] +>Iterator.zipKeyed(instance, { mode: "strict" }).toArray() : Record[] +>Iterator.zipKeyed(instance, { mode: "strict" }).toArray : () => Record[] +>Iterator.zipKeyed(instance, { mode: "strict" }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>instance : InputsWithPrototypeMembers +>{ mode: "strict" } : { mode: "strict"; } +>mode : "strict" +>"strict" : "strict" +>toArray : () => Record[] + +const inheritedLongest = Iterator.zipKeyed(instance, { mode: "longest" }).toArray(); +>inheritedLongest : Record[] +>Iterator.zipKeyed(instance, { mode: "longest" }).toArray() : Record[] +>Iterator.zipKeyed(instance, { mode: "longest" }).toArray : () => Record[] +>Iterator.zipKeyed(instance, { mode: "longest" }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>instance : InputsWithPrototypeMembers +>{ mode: "longest" } : { mode: "longest"; } +>mode : "longest" +>"longest" : "longest" +>toArray : () => Record[] + +const inheritedPadded = Iterator.zipKeyed(instance, { mode: "longest", padding: { values: 0 } }).toArray(); +>inheritedPadded : Record[] +>Iterator.zipKeyed(instance, { mode: "longest", padding: { values: 0 } }).toArray() : Record[] +>Iterator.zipKeyed(instance, { mode: "longest", padding: { values: 0 } }).toArray : () => Record[] +>Iterator.zipKeyed(instance, { mode: "longest", padding: { values: 0 } }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>instance : InputsWithPrototypeMembers +>{ mode: "longest", padding: { values: 0 } } : { mode: "longest"; padding: { values: number; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { values: number; } +>{ values: 0 } : { values: number; } +>values : number +>0 : 0 +>toArray : () => Record[] + +const hiddenInputs = { values: [1, 2], label: "inputs" }; +>hiddenInputs : { values: number[]; label: string; } +>{ values: [1, 2], label: "inputs" } : { values: number[]; label: string; } +>values : number[] +>[1, 2] : number[] +>1 : 1 +>2 : 2 +>label : string +>"inputs" : "inputs" + +Object.defineProperty(hiddenInputs, "label", { enumerable: false }); +>Object.defineProperty(hiddenInputs, "label", { enumerable: false }) : { values: number[]; label: string; } +>Object.defineProperty : (o: T, p: PropertyKey, attributes: PropertyDescriptor & ThisType) => T +>Object : ObjectConstructor +>defineProperty : (o: T, p: PropertyKey, attributes: PropertyDescriptor & ThisType) => T +>hiddenInputs : { values: number[]; label: string; } +>"label" : "label" +>{ enumerable: false } : { enumerable: false; } +>enumerable : false +>false : false + +const nonEnumerable = Iterator.zipKeyed(hiddenInputs).toArray(); +>nonEnumerable : Record[] +>Iterator.zipKeyed(hiddenInputs).toArray() : Record[] +>Iterator.zipKeyed(hiddenInputs).toArray : () => Record[] +>Iterator.zipKeyed(hiddenInputs) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>hiddenInputs : { values: number[]; label: string; } +>toArray : () => Record[] + +const nonEnumerablePadded = Iterator.zipKeyed(hiddenInputs, { mode: "longest", padding: { values: 0 } }).toArray(); +>nonEnumerablePadded : Record[] +>Iterator.zipKeyed(hiddenInputs, { mode: "longest", padding: { values: 0 } }).toArray() : Record[] +>Iterator.zipKeyed(hiddenInputs, { mode: "longest", padding: { values: 0 } }).toArray : () => Record[] +>Iterator.zipKeyed(hiddenInputs, { mode: "longest", padding: { values: 0 } }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>hiddenInputs : { values: number[]; label: string; } +>{ mode: "longest", padding: { values: 0 } } : { mode: "longest"; padding: { values: number; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { values: number; } +>{ values: 0 } : { values: number; } +>values : number +>0 : 0 +>toArray : () => Record[] + +// The same static shape can have an enumerable non-iterator property instead. +// Such inputs are accepted by the fallback and checked at runtime. +const enumerableInputs = { values: [1, 2], label: "inputs" }; +>enumerableInputs : { values: number[]; label: string; } +>{ values: [1, 2], label: "inputs" } : { values: number[]; label: string; } +>values : number[] +>[1, 2] : number[] +>1 : 1 +>2 : 2 +>label : string +>"inputs" : "inputs" + +const enumerable = Iterator.zipKeyed(enumerableInputs).toArray(); +>enumerable : Record[] +>Iterator.zipKeyed(enumerableInputs).toArray() : Record[] +>Iterator.zipKeyed(enumerableInputs).toArray : () => Record[] +>Iterator.zipKeyed(enumerableInputs) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>enumerableInputs : { values: number[]; label: string; } +>toArray : () => Record[] + +// The array's length and methods are not enumerable own properties. +const arrayInputs = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); +>arrayInputs : Record[] +>Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray() : Record[] +>Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray : () => Record[] +>Iterator.zipKeyed([[1, 2], ["a", "b"]]) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>[[1, 2], ["a", "b"]] : (string[] | number[])[] +>[1, 2] : number[] +>1 : 1 +>2 : 2 +>["a", "b"] : string[] +>"a" : "a" +>"b" : "b" +>toArray : () => Record[] + +// The fallback must not claim that ignored properties exist on yielded objects. +const inheritedLabel: string = inherited[0].label; +>inheritedLabel : string +>inherited[0].label : unknown +>inherited[0] : Record +>inherited : Record[] +>0 : 0 +>label : unknown + +const nonEnumerableLabel: string = nonEnumerable[0].label; +>nonEnumerableLabel : string +>nonEnumerable[0].label : unknown +>nonEnumerable[0] : Record +>nonEnumerable : Record[] +>0 : 0 +>label : unknown + +// Precise record inference still handles symbol keys and padding. +declare const ownKey: unique symbol; +>ownKey : unique symbol + +const precise: { values: number; [ownKey]: string; }[] = Iterator.zipKeyed({ values: [1], [ownKey]: ["a"] }).toArray(); +>precise : { values: number; [ownKey]: string; }[] +>values : number +>[ownKey] : string +>ownKey : unique symbol +>Iterator.zipKeyed({ values: [1], [ownKey]: ["a"] }).toArray() : { values: number; [ownKey]: string; }[] +>Iterator.zipKeyed({ values: [1], [ownKey]: ["a"] }).toArray : () => { values: number; [ownKey]: string; }[] +>Iterator.zipKeyed({ values: [1], [ownKey]: ["a"] }) : IteratorObject<{ values: number; [ownKey]: string; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ values: [1], [ownKey]: ["a"] } : { values: number[]; [ownKey]: string[]; } +>values : number[] +>[1] : number[] +>1 : 1 +>[ownKey] : string[] +>ownKey : unique symbol +>["a"] : string[] +>"a" : "a" +>toArray : () => { values: number; [ownKey]: string; }[] + +const preciseLongest: { values: number | undefined; }[] = Iterator.zipKeyed({ values: [1] }, { mode: "longest" }).toArray(); +>preciseLongest : { values: number | undefined; }[] +>values : number | undefined +>Iterator.zipKeyed({ values: [1] }, { mode: "longest" }).toArray() : { values: number | undefined; }[] +>Iterator.zipKeyed({ values: [1] }, { mode: "longest" }).toArray : () => { values: number | undefined; }[] +>Iterator.zipKeyed({ values: [1] }, { mode: "longest" }) : IteratorObject<{ values: number | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ values: [1] } : { values: number[]; } +>values : number[] +>[1] : number[] +>1 : 1 +>{ mode: "longest" } : { mode: "longest"; } +>mode : "longest" +>"longest" : "longest" +>toArray : () => { values: number | undefined; }[] + +const precisePadded: { values: number; }[] = Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: 0 } }).toArray(); +>precisePadded : { values: number; }[] +>values : number +>Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: 0 } }).toArray() : { values: number; }[] +>Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: 0 } }).toArray : () => { values: number; }[] +>Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: 0 } }) : IteratorObject<{ values: number; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ values: [1] } : { values: number[]; } +>values : number[] +>[1] : number[] +>1 : 1 +>{ mode: "longest", padding: { values: 0 } } : { mode: "longest"; padding: { values: number; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { values: number; } +>{ values: 0 } : { values: number; } +>values : number +>0 : 0 +>toArray : () => { values: number; }[] + +const emptyOwnProperties: never[] = Iterator.zipKeyed({}).toArray(); +>emptyOwnProperties : never[] +>Iterator.zipKeyed({}).toArray() : never[] +>Iterator.zipKeyed({}).toArray : () => never[] +>Iterator.zipKeyed({}) : IteratorObject +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{} : {} +>toArray : () => never[] + +Iterator.zipKeyed(0); +>Iterator.zipKeyed(0) : IteratorObject +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>0 : 0 + +Iterator.zipKeyed(null); +>Iterator.zipKeyed(null) : IteratorObject +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } + +Iterator.zipKeyed(instance, { mode: "invalid" }); +>Iterator.zipKeyed(instance, { mode: "invalid" }) : IteratorObject<{ values: number; label: never; describe: never; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>instance : InputsWithPrototypeMembers +>{ mode: "invalid" } : { mode: "invalid"; } +>mode : "invalid" +>"invalid" : "invalid" + +Iterator.zipKeyed(instance, { mode: "shortest", padding: {} }); +>Iterator.zipKeyed(instance, { mode: "shortest", padding: {} }) : IteratorObject<{ values: number; label: never; describe: never; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>instance : InputsWithPrototypeMembers +>{ mode: "shortest", padding: {} } : { mode: "shortest"; padding: {}; } +>mode : "shortest" +>"shortest" : "shortest" +>padding : {} +>{} : {} + +Iterator.zipKeyed(instance, { mode: "longest", padding: 0 }); +>Iterator.zipKeyed(instance, { mode: "longest", padding: 0 }) : IteratorObject<{ values: number; label: never; describe: never; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>instance : InputsWithPrototypeMembers +>{ mode: "longest", padding: 0 } : { mode: "longest"; padding: number; } +>mode : "longest" +>"longest" : "longest" +>padding : number +>0 : 0 + +Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: "invalid" } }); +>Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: "invalid" } }) : IteratorObject<{ values: number; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ values: [1] } : { values: number[]; } +>values : number[] +>[1] : number[] +>1 : 1 +>{ mode: "longest", padding: { values: "invalid" } } : { mode: "longest"; padding: { values: string; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { values: string; } +>{ values: "invalid" } : { values: string; } +>values : string +>"invalid" : "invalid" + diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).errors.txt b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).errors.txt new file mode 100644 index 0000000000000..d9df07d45c33f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).errors.txt @@ -0,0 +1,631 @@ +iteratorZip.ts(62,23): error TS2769: No overload matches this call. + The last overload gave the following error. + Type '"invalid"' is not assignable to type '"longest" | "shortest" | "strict"'. +iteratorZip.ts(64,56): error TS2769: No overload matches this call. + The last overload gave the following error. + Type 'true[]' is not assignable to type 'Iterable<"a" | 1 | undefined> & object'. + Type 'true[]' is not assignable to type 'Iterable<"a" | 1 | undefined>'. + The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. + Type 'IteratorResult' is not assignable to type 'IteratorResult<"a" | 1 | undefined, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. + Type 'IteratorYieldResult' is not assignable to type 'IteratorResult<"a" | 1 | undefined, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. + Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult<"a" | 1 | undefined>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. + Type 'true' is not assignable to type '"a" | 1 | undefined'. +iteratorZip.ts(66,41): error TS2769: No overload matches this call. + The last overload gave the following error. + Object literal may only specify known properties, and 'padding' does not exist in type 'IteratorZipShortestOptions'. +iteratorZip.ts(68,14): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type 'number' is not assignable to parameter of type 'Iterable> & object'. + Type 'number' is not assignable to type 'Iterable>'. +iteratorZip.ts(80,14): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type 'string' is not assignable to parameter of type 'Iterable> & object'. + Type 'string' is not assignable to type 'Iterable>'. +iteratorZip.ts(81,14): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type 'string[]' is not assignable to parameter of type 'Iterable> & object'. + Type 'string[]' is not assignable to type 'Iterable>'. + The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. + Type 'IteratorResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. + Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. + Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. + Type 'string' is not assignable to type 'IteratorInput'. +iteratorZip.ts(82,14): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type 'Set' is not assignable to parameter of type 'Iterable> & object'. + Type 'Set' is not assignable to type 'Iterable>'. + The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. + Type 'IteratorResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. + Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. + Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. + Type 'string' is not assignable to type 'IteratorInput'. +iteratorZip.ts(83,19): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type '"ab"' is not assignable to parameter of type 'never'. +iteratorZip.ts(85,37): error TS2769: No overload matches this call. + The last overload gave the following error. + Type 'string' is not assignable to type 'Iterable & object'. + Type 'string' is not assignable to type 'Iterable'. +iteratorZip.ts(86,42): error TS2769: No overload matches this call. + The last overload gave the following error. + Type 'string' is not assignable to type 'Iterable & object'. + Type 'string' is not assignable to type 'object'. +iteratorZip.ts(87,19): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type '{}' is not assignable to parameter of type 'never'. +iteratorZip.ts(95,6): error TS2339: Property 'b' does not exist on type 'IteratorZipResult<{ a: number[]; } & {}, never, {}>'. +iteratorZip.ts(111,6): error TS2339: Property 'd' does not exist on type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator; readonly c?: Iterable | undefined; }, never, {}>'. +iteratorZip.ts(112,7): error TS2322: Type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator; readonly c?: Iterable | undefined; }, never, {}>[]' is not assignable to type '{ a: number; c: boolean; }[]'. + Type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator; readonly c?: Iterable | undefined; }, never, {}>' is not assignable to type '{ a: number; c: boolean; }'. + Property 'c' is optional in type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator; readonly c?: Iterable | undefined; }, never, {}>' but required in type '{ a: number; c: boolean; }'. +iteratorZip.ts(132,14): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type 'undefined[]' is not assignable to parameter of type 'Iterable> & object'. + Type 'undefined[]' is not assignable to type 'Iterable>'. + The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. + Type 'IteratorResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. + Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. + Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. + Type 'undefined' is not assignable to type 'IteratorInput'. +iteratorZip.ts(150,7): error TS2322: Type '[number, ...(number | undefined)[]][]' is not assignable to type 'number[][]'. + Type '[number, ...(number | undefined)[]]' is not assignable to type 'number[]'. + Type 'number | undefined' is not assignable to type 'number'. + Type 'undefined' is not assignable to type 'number'. +iteratorZip.ts(155,7): error TS2322: Type 'IteratorZipResult<{ [x: string]: Iterable; } & {}, undefined, {}>[]' is not assignable to type 'Record[]'. + Type 'IteratorZipResult<{ [x: string]: Iterable; } & {}, undefined, {}>' is not assignable to type 'Record'. + 'string' index signatures are incompatible. + Type 'number | undefined' is not assignable to type 'number'. + Type 'undefined' is not assignable to type 'number'. +iteratorZip.ts(160,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record>[]' is not assignable to type '{ a: number; b: number; }[]'. + Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record>' is not assignable to type '{ a: number; b: number; }'. + Types of property 'a' are incompatible. + Type 'number | undefined' is not assignable to type 'number'. + Type 'undefined' is not assignable to type 'number'. +iteratorZip.ts(169,7): error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. + Type '[number, string | undefined]' is not assignable to type '[number, string]'. + Type at position 1 in source is not compatible with type at position 1 in target. + Type 'string | undefined' is not assignable to type 'string'. + Type 'undefined' is not assignable to type 'string'. +iteratorZip.ts(172,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; }>[]' is not assignable to type '{ a: number; b: string; }[]'. + Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; b: string; }'. + Types of property 'b' are incompatible. + Type 'string | undefined' is not assignable to type 'string'. + Type 'undefined' is not assignable to type 'string'. +iteratorZip.ts(178,7): error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. + Type '[number, string | undefined]' is not assignable to type '[number, string]'. + Type at position 1 in source is not compatible with type at position 1 in target. + Type 'string | undefined' is not assignable to type 'string'. + Type 'undefined' is not assignable to type 'string'. +iteratorZip.ts(182,7): error TS2322: Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>[]' is not assignable to type 'number[][]'. + Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>' is not assignable to type 'number[]'. + Type '[number, number | undefined]' is not assignable to type 'number[]'. + Type 'number | undefined' is not assignable to type 'number'. + Type 'undefined' is not assignable to type 'number'. +iteratorZip.ts(185,7): error TS2322: Type '(IteratorZipResult<{ a: Iterable; } & {}, undefined, { a: number; }> | IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>)[]' is not assignable to type '({ a: number; } | { b: string; })[]'. + Type 'IteratorZipResult<{ a: Iterable; } & {}, undefined, { a: number; }> | IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; } | { b: string; }'. + Type 'IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; } | { b: string; }'. + Type 'IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ b: string; }'. + Types of property 'b' are incompatible. + Type 'string | undefined' is not assignable to type 'string'. + Type 'undefined' is not assignable to type 'string'. +iteratorZip.ts(189,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; } | { b: string; }>[]' is not assignable to type '{ a: number; b: string; }[]'. + Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; } | { b: string; }>' is not assignable to type '{ a: number; b: string; }'. + Types of property 'a' are incompatible. + Type 'number | undefined' is not assignable to type 'number'. + Type 'undefined' is not assignable to type 'number'. +iteratorZip.ts(192,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, { a: undefined; b: number; }>[]' is not assignable to type '{ a: number; b: number; }[]'. + Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, { a: undefined; b: number; }>' is not assignable to type '{ a: number; b: number; }'. + Types of property 'a' are incompatible. + Type 'number | undefined' is not assignable to type 'number'. + Type 'undefined' is not assignable to type 'number'. +iteratorZip.ts(196,7): error TS2322: Type 'IteratorZipResult<{ [x: `a${string}`]: Iterable; } & {}, undefined, {}>[]' is not assignable to type '{ [x: `a${string}`]: number; }[]'. + Type 'IteratorZipResult<{ [x: `a${string}`]: Iterable; } & {}, undefined, {}>' is not assignable to type '{ [x: `a${string}`]: number; }'. + '`a${string}`' index signatures are incompatible. + Type 'number | undefined' is not assignable to type 'number'. + Type 'undefined' is not assignable to type 'number'. +iteratorZip.ts(204,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record & { a: number; }>[]' is not assignable to type '{ a: number; b: number; }[]'. + Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record & { a: number; }>' is not assignable to type '{ a: number; b: number; }'. + Types of property 'b' are incompatible. + Type 'number | undefined' is not assignable to type 'number'. + Type 'undefined' is not assignable to type 'number'. +iteratorZip.ts(209,7): error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. + Type '[number, string | undefined]' is not assignable to type '[number, string]'. + Type at position 1 in source is not compatible with type at position 1 in target. + Type 'string | undefined' is not assignable to type 'string'. + Type 'undefined' is not assignable to type 'string'. +iteratorZip.ts(248,7): error TS2322: Type 'unknown' is not assignable to type 'string'. +iteratorZip.ts(249,7): error TS2322: Type 'unknown' is not assignable to type 'string'. +iteratorZip.ts(258,19): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type '0' is not assignable to parameter of type 'never'. +iteratorZip.ts(259,19): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type 'null' is not assignable to parameter of type 'never'. +iteratorZip.ts(260,31): error TS2769: No overload matches this call. + The last overload gave the following error. + Type '"invalid"' is not assignable to type '"longest" | "shortest" | "strict" | undefined'. +iteratorZip.ts(261,49): error TS2769: No overload matches this call. + The last overload gave the following error. + Object literal may only specify known properties, and 'padding' does not exist in type 'IteratorZipShortestOptions'. +iteratorZip.ts(262,48): error TS2769: No overload matches this call. + The last overload gave the following error. + Type 'number' is not assignable to type 'object'. +iteratorZip.ts(263,19): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type '{ values: number[]; }' is not assignable to parameter of type 'never'. + + +==== iteratorZip.ts (36 errors) ==== + declare const key: unique symbol; + + const tuples: [number, string][] = Iterator.zip([ + [1, 2], + new Set(["a", "b"]), + ] as const).toArray(); + + tuples[0][0] = 2; + + const shortestTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray(); + const strictTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray(); + const longestTuplesWithPadding: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray(); + const longestTuplesWithoutPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray(); + const longestTuplesWithPartialPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray(); + + declare const maybeLongestOptions: { mode: "shortest"; } | { mode: "longest"; }; + const maybeLongestTuples: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray(); + + const empty: never[] = Iterator.zip([]).toArray(); + const emptyLongest: never[] = Iterator.zip([], { mode: "longest" }).toArray(); + + declare const iterables: Iterable>; + const arrays: number[][] = Iterator.zip(iterables).toArray(); + const longestArrays: (number | undefined)[][] = Iterator.zip(iterables, { mode: "longest" }).toArray(); + const maybeLongestArrays: (number | undefined)[][] = Iterator.zip(iterables, maybeLongestOptions).toArray(); + + declare const iterableArray: Iterable[]; + const longestArrayWithPadding: (number | undefined)[][] = Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray(); + + const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ + a: [1, 2], + b: new Set(["a", "b"]), + [key]: [true, false], + } as const).toArray(); + + objects[0].a = 2; + + const longestObjectsWithPadding: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { + mode: "longest", + padding: { a: 1, b: "a" }, + }).toArray(); + + const longestObjectsWithoutPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { + mode: "longest", + }).toArray(); + + const longestObjectsWithPartialPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { + mode: "longest", + padding: { b: "a" }, + }).toArray(); + + const maybeLongestObjects: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray(); + + interface Inputs { + a: Iterable; + b: Iterator; + } + + declare const inputs: Inputs; + const rows: { a: number; b: string; }[] = Iterator.zipKeyed(inputs).toArray(); + + Iterator.zip([[1]], { mode: "invalid" }); + ~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Type '"invalid"' is not assignable to type '"longest" | "shortest" | "strict"'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + + Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }); + ~~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Type 'true[]' is not assignable to type 'Iterable<"a" | 1 | undefined> & object'. +!!! error TS2769: Type 'true[]' is not assignable to type 'Iterable<"a" | 1 | undefined>'. +!!! error TS2769: The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. +!!! error TS2769: Type 'IteratorResult' is not assignable to type 'IteratorResult<"a" | 1 | undefined, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. +!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorResult<"a" | 1 | undefined, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. +!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult<"a" | 1 | undefined>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. +!!! error TS2769: Type 'true' is not assignable to type '"a" | 1 | undefined'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + + Iterator.zip([[1]], { mode: "shortest", padding: [1] }); + ~~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Object literal may only specify known properties, and 'padding' does not exist in type 'IteratorZipShortestOptions'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + + Iterator.zip(0); + ~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type 'number' is not assignable to parameter of type 'Iterable> & object'. +!!! error TS2769: Type 'number' is not assignable to type 'Iterable>'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + + Iterator.zipKeyed({ a: 0 }); + + const emptyKeyed: never[] = Iterator.zipKeyed({}).toArray(); + const emptyKeyedLongest: never[] = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); + + declare const unionInputs: { a: Iterable; } | { b: Iterator; }; + const unionRows: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(unionInputs).toArray(); + + // Inputs + + Iterator.zip("ab"); + ~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type 'string' is not assignable to parameter of type 'Iterable> & object'. +!!! error TS2769: Type 'string' is not assignable to type 'Iterable>'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + Iterator.zip(["ab"]); + ~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type 'string[]' is not assignable to parameter of type 'Iterable> & object'. +!!! error TS2769: Type 'string[]' is not assignable to type 'Iterable>'. +!!! error TS2769: The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. +!!! error TS2769: Type 'IteratorResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. +!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. +!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. +!!! error TS2769: Type 'string' is not assignable to type 'IteratorInput'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + Iterator.zip(new Set(["ab"])); + ~~~~~~~~~~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type 'Set' is not assignable to parameter of type 'Iterable> & object'. +!!! error TS2769: Type 'Set' is not assignable to type 'Iterable>'. +!!! error TS2769: The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. +!!! error TS2769: Type 'IteratorResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. +!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. +!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. +!!! error TS2769: Type 'string' is not assignable to type 'IteratorInput'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + Iterator.zipKeyed("ab"); + ~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type '"ab"' is not assignable to parameter of type 'never'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + Iterator.zipKeyed({ a: "ab" }); + Iterator.zip([], { mode: "longest", padding: "ab" }); + ~~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Type 'string' is not assignable to type 'Iterable & object'. +!!! error TS2769: Type 'string' is not assignable to type 'Iterable'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); + ~~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Type 'string' is not assignable to type 'Iterable & object'. +!!! error TS2769: Type 'string' is not assignable to type 'object'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); + ~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type '{}' is not assignable to parameter of type 'never'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + + const a: [string][] = Iterator.zip([new String("ab")]).toArray(); + const b: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); + const c: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); + + const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); + const e: { a: number; }[] = d; + d[0].b; + ~ +!!! error TS2339: Property 'b' does not exist on type 'IteratorZipResult<{ a: number[]; } & {}, never, {}>'. + const f: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); + const g: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); + + interface I { + readonly a: Iterable; + readonly b?: Iterator; + readonly c: Iterable | undefined; + readonly d?: undefined; + } + declare const h: I; + const i = Iterator.zipKeyed(h).toArray(); + const j: { a: number; b?: string; c?: boolean; }[] = i; + i[0].a = 2; + i[0].b = "a"; + i[0].c = true; + i[0].d; + ~ +!!! error TS2339: Property 'd' does not exist on type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator; readonly c?: Iterable | undefined; }, never, {}>'. + const k: { a: number; c: boolean; }[] = i; + ~ +!!! error TS2322: Type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator; readonly c?: Iterable | undefined; }, never, {}>[]' is not assignable to type '{ a: number; c: boolean; }[]'. +!!! error TS2322: Type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator; readonly c?: Iterable | undefined; }, never, {}>' is not assignable to type '{ a: number; c: boolean; }'. +!!! error TS2322: Property 'c' is optional in type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator; readonly c?: Iterable | undefined; }, never, {}>' but required in type '{ a: number; c: boolean; }'. + const l: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); + + declare const m: { a: Iterable; } | { b: Iterator; }; + const n: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(m).toArray(); + declare const o: { a: Iterable; } | { b: number; }; + Iterator.zipKeyed(o); + Iterator.zipKeyed(o, { mode: "longest" }); + Iterator.zipKeyed(o, { mode: "longest", padding: {} }); + declare const p: { a?: Iterable; } | { b: string; }; + Iterator.zipKeyed(p); + declare const q: { a: Iterable; } | { b: undefined; }; + const r: { a: number; }[] = Iterator.zipKeyed(q).toArray(); + + declare const s: unique symbol; + declare const t: { a: Iterable; [s]?: Iterable; }; + const u: { a: number; [s]?: string; }[] = Iterator.zipKeyed(t).toArray(); + + Iterator.zipKeyed({ a: [1], b: null }); + Iterator.zipKeyed({ a: [1], b: false }); + Iterator.zip([undefined]); + ~~~~~~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type 'undefined[]' is not assignable to parameter of type 'Iterable> & object'. +!!! error TS2769: Type 'undefined[]' is not assignable to type 'Iterable>'. +!!! error TS2769: The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. +!!! error TS2769: Type 'IteratorResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. +!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. +!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. +!!! error TS2769: Type 'undefined' is not assignable to type 'IteratorInput'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + + declare const v: { a?: undefined; }; + const w: never[] = Iterator.zipKeyed(v).toArray(); + const x: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); + const y: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); + + function f1(a: Iterable) { + const b: { a: T; }[] = Iterator.zipKeyed({ a }).toArray(); + const c: [T][] = Iterator.zip([a]).toArray(); + return { b, c }; + } + + // Padding + + const paddingA: [Iterable, ...Iterable[]] = [[1, 2], [3]]; + const paddingB = Iterator.zip(paddingA, { mode: "longest", padding: [0] }).toArray(); + const paddingC: (number | undefined)[][] = paddingB; + const paddingD: number[][] = paddingB; + ~~~~~~~~ +!!! error TS2322: Type '[number, ...(number | undefined)[]][]' is not assignable to type 'number[][]'. +!!! error TS2322: Type '[number, ...(number | undefined)[]]' is not assignable to type 'number[]'. +!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'undefined' is not assignable to type 'number'. + + const paddingE: Record> = { a: [1], b: [2, 3] }; + const paddingF = Iterator.zipKeyed(paddingE, { mode: "longest", padding: {} }).toArray(); + const paddingG: Record[] = paddingF; + const paddingH: Record[] = paddingF; + ~~~~~~~~ +!!! error TS2322: Type 'IteratorZipResult<{ [x: string]: Iterable; } & {}, undefined, {}>[]' is not assignable to type 'Record[]'. +!!! error TS2322: Type 'IteratorZipResult<{ [x: string]: Iterable; } & {}, undefined, {}>' is not assignable to type 'Record'. +!!! error TS2322: 'string' index signatures are incompatible. +!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'undefined' is not assignable to type 'number'. + + declare const paddingI: Record; + const paddingJ = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: paddingI }).toArray(); + const paddingK: { a: number | undefined; b: number | undefined; }[] = paddingJ; + const paddingL: { a: number; b: number; }[] = paddingJ; + ~~~~~~~~ +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record>[]' is not assignable to type '{ a: number; b: number; }[]'. +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record>' is not assignable to type '{ a: number; b: number; }'. +!!! error TS2322: Types of property 'a' are incompatible. +!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'undefined' is not assignable to type 'number'. + + const paddingM = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); + const paddingN: [number, string][] = paddingM; + const paddingO = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); + const paddingP: { a: number; b: string; }[] = paddingO; + + const paddingQ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); + const paddingR: [number | undefined, string | undefined][] = paddingQ; + const paddingS: [number, string][] = paddingQ; + ~~~~~~~~ +!!! error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. +!!! error TS2322: Type '[number, string | undefined]' is not assignable to type '[number, string]'. +!!! error TS2322: Type at position 1 in source is not compatible with type at position 1 in target. +!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. +!!! error TS2322: Type 'undefined' is not assignable to type 'string'. + const paddingT = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); + const paddingU: { a: number | undefined; b: string | undefined; }[] = paddingT; + const paddingV: { a: number; b: string; }[] = paddingT; + ~~~~~~~~ +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; }>[]' is not assignable to type '{ a: number; b: string; }[]'. +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; b: string; }'. +!!! error TS2322: Types of property 'b' are incompatible. +!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. +!!! error TS2322: Type 'undefined' is not assignable to type 'string'. + + declare const paddingW: readonly [number, string]; + const paddingX: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingW }).toArray(); + declare const paddingY: [number, string?]; + const paddingZ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY }).toArray(); + const paddingA1: [number, string][] = paddingZ; + ~~~~~~~~~ +!!! error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. +!!! error TS2322: Type '[number, string | undefined]' is not assignable to type '[number, string]'. +!!! error TS2322: Type at position 1 in source is not compatible with type at position 1 in target. +!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. +!!! error TS2322: Type 'undefined' is not assignable to type 'string'. + + declare const paddingB1: [Iterable] | [Iterable, Iterable]; + const paddingC1 = Iterator.zip(paddingB1, { mode: "longest", padding: [0] }).toArray(); + const paddingD1: number[][] = paddingC1; + ~~~~~~~~~ +!!! error TS2322: Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>[]' is not assignable to type 'number[][]'. +!!! error TS2322: Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>' is not assignable to type 'number[]'. +!!! error TS2322: Type '[number, number | undefined]' is not assignable to type 'number[]'. +!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'undefined' is not assignable to type 'number'. + declare const paddingE1: { a: Iterable; } | { b: Iterable; }; + const paddingF1 = Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: 0 } }).toArray(); + const paddingG1: ({ a: number; } | { b: string; })[] = paddingF1; + ~~~~~~~~~ +!!! error TS2322: Type '(IteratorZipResult<{ a: Iterable; } & {}, undefined, { a: number; }> | IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>)[]' is not assignable to type '({ a: number; } | { b: string; })[]'. +!!! error TS2322: Type 'IteratorZipResult<{ a: Iterable; } & {}, undefined, { a: number; }> | IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; } | { b: string; }'. +!!! error TS2322: Type 'IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; } | { b: string; }'. +!!! error TS2322: Type 'IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ b: string; }'. +!!! error TS2322: Types of property 'b' are incompatible. +!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. +!!! error TS2322: Type 'undefined' is not assignable to type 'string'. + + declare const paddingH1: { a: number; } | { b: string; }; + const paddingI1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: paddingH1 }).toArray(); + const paddingJ1: { a: number; b: string; }[] = paddingI1; + ~~~~~~~~~ +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; } | { b: string; }>[]' is not assignable to type '{ a: number; b: string; }[]'. +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; } | { b: string; }>' is not assignable to type '{ a: number; b: string; }'. +!!! error TS2322: Types of property 'a' are incompatible. +!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'undefined' is not assignable to type 'number'. + + const paddingK1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); + const paddingL1: { a: number; b: number; }[] = paddingK1; + ~~~~~~~~~ +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, { a: undefined; b: number; }>[]' is not assignable to type '{ a: number; b: number; }[]'. +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, { a: undefined; b: number; }>' is not assignable to type '{ a: number; b: number; }'. +!!! error TS2322: Types of property 'a' are incompatible. +!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'undefined' is not assignable to type 'number'. + + declare const paddingM1: { [K in `a${string}`]: Iterable; }; + const paddingN1 = Iterator.zipKeyed(paddingM1, { mode: "longest", padding: {} }).toArray(); + const paddingO1: { [K in `a${string}`]: number; }[] = paddingN1; + ~~~~~~~~~ +!!! error TS2322: Type 'IteratorZipResult<{ [x: `a${string}`]: Iterable; } & {}, undefined, {}>[]' is not assignable to type '{ [x: `a${string}`]: number; }[]'. +!!! error TS2322: Type 'IteratorZipResult<{ [x: `a${string}`]: Iterable; } & {}, undefined, {}>' is not assignable to type '{ [x: `a${string}`]: number; }'. +!!! error TS2322: '`a${string}`' index signatures are incompatible. +!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'undefined' is not assignable to type 'number'. + + declare const paddingP1: unique symbol; + const paddingQ1: { [paddingP1]: number; }[] = Iterator.zipKeyed({ [paddingP1]: [1] }, { mode: "longest", padding: { [paddingP1]: 0 } }).toArray(); + + declare const paddingR1: Record & { a: number; }; + const paddingS1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: paddingR1 }).toArray(); + const paddingT1: { a: number; b: number | undefined; }[] = paddingS1; + const paddingU1: { a: number; b: number; }[] = paddingS1; + ~~~~~~~~~ +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record & { a: number; }>[]' is not assignable to type '{ a: number; b: number; }[]'. +!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record & { a: number; }>' is not assignable to type '{ a: number; b: number; }'. +!!! error TS2322: Types of property 'b' are incompatible. +!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'undefined' is not assignable to type 'number'. + + declare const paddingV1: [number] | [number, string]; + const paddingW1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingV1 }).toArray(); + const paddingX1: [number, string | undefined][] = paddingW1; + const paddingY1: [number, string][] = paddingW1; + ~~~~~~~~~ +!!! error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. +!!! error TS2322: Type '[number, string | undefined]' is not assignable to type '[number, string]'. +!!! error TS2322: Type at position 1 in source is not compatible with type at position 1 in target. +!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. +!!! error TS2322: Type 'undefined' is not assignable to type 'string'. + + const paddingZ1: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); + const paddingA2: { a: number | undefined; b: number; }[] = paddingK1; + + // Own properties + + class InputsWithPrototypeMembers { + values = [1, 2]; + + get label() { + return "inputs"; + } + + describe() { + return this.label; + } + } + + const instance = new InputsWithPrototypeMembers(); + const inherited = Iterator.zipKeyed(instance).toArray(); + const inheritedStrict = Iterator.zipKeyed(instance, { mode: "strict" }).toArray(); + const inheritedLongest = Iterator.zipKeyed(instance, { mode: "longest" }).toArray(); + const inheritedPadded = Iterator.zipKeyed(instance, { mode: "longest", padding: { values: 0 } }).toArray(); + + const hiddenInputs = { values: [1, 2], label: "inputs" }; + Object.defineProperty(hiddenInputs, "label", { enumerable: false }); + const nonEnumerable = Iterator.zipKeyed(hiddenInputs).toArray(); + const nonEnumerablePadded = Iterator.zipKeyed(hiddenInputs, { mode: "longest", padding: { values: 0 } }).toArray(); + + // The same static shape can have an enumerable non-iterator property instead. + // Such inputs are accepted by the fallback and checked at runtime. + const enumerableInputs = { values: [1, 2], label: "inputs" }; + const enumerable = Iterator.zipKeyed(enumerableInputs).toArray(); + + // The array's length and methods are not enumerable own properties. + const arrayInputs = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); + + // The fallback must not claim that ignored properties exist on yielded objects. + const inheritedLabel: string = inherited[0].label; + ~~~~~~~~~~~~~~ +!!! error TS2322: Type 'unknown' is not assignable to type 'string'. + const nonEnumerableLabel: string = nonEnumerable[0].label; + ~~~~~~~~~~~~~~~~~~ +!!! error TS2322: Type 'unknown' is not assignable to type 'string'. + + // Precise record inference still handles symbol keys and padding. + declare const ownKey: unique symbol; + const precise: { values: number; [ownKey]: string; }[] = Iterator.zipKeyed({ values: [1], [ownKey]: ["a"] }).toArray(); + const preciseLongest: { values: number | undefined; }[] = Iterator.zipKeyed({ values: [1] }, { mode: "longest" }).toArray(); + const precisePadded: { values: number; }[] = Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: 0 } }).toArray(); + const emptyOwnProperties: never[] = Iterator.zipKeyed({}).toArray(); + + Iterator.zipKeyed(0); + ~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type '0' is not assignable to parameter of type 'never'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + Iterator.zipKeyed(null); + ~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type 'null' is not assignable to parameter of type 'never'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + Iterator.zipKeyed(instance, { mode: "invalid" }); + ~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Type '"invalid"' is not assignable to type '"longest" | "shortest" | "strict" | undefined'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + Iterator.zipKeyed(instance, { mode: "shortest", padding: {} }); + ~~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Object literal may only specify known properties, and 'padding' does not exist in type 'IteratorZipShortestOptions'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + Iterator.zipKeyed(instance, { mode: "longest", padding: 0 }); + ~~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Type 'number' is not assignable to type 'object'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: "invalid" } }); + ~~~~~~~~~~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type '{ values: number[]; }' is not assignable to parameter of type 'never'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).js b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).js new file mode 100644 index 0000000000000..893920834439d --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).js @@ -0,0 +1,762 @@ +//// [tests/cases/compiler/iteratorZip.ts] //// + +//// [iteratorZip.ts] +declare const key: unique symbol; + +const tuples: [number, string][] = Iterator.zip([ + [1, 2], + new Set(["a", "b"]), +] as const).toArray(); + +tuples[0][0] = 2; + +const shortestTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray(); +const strictTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray(); +const longestTuplesWithPadding: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray(); +const longestTuplesWithoutPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray(); +const longestTuplesWithPartialPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray(); + +declare const maybeLongestOptions: { mode: "shortest"; } | { mode: "longest"; }; +const maybeLongestTuples: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray(); + +const empty: never[] = Iterator.zip([]).toArray(); +const emptyLongest: never[] = Iterator.zip([], { mode: "longest" }).toArray(); + +declare const iterables: Iterable>; +const arrays: number[][] = Iterator.zip(iterables).toArray(); +const longestArrays: (number | undefined)[][] = Iterator.zip(iterables, { mode: "longest" }).toArray(); +const maybeLongestArrays: (number | undefined)[][] = Iterator.zip(iterables, maybeLongestOptions).toArray(); + +declare const iterableArray: Iterable[]; +const longestArrayWithPadding: (number | undefined)[][] = Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray(); + +const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ + a: [1, 2], + b: new Set(["a", "b"]), + [key]: [true, false], +} as const).toArray(); + +objects[0].a = 2; + +const longestObjectsWithPadding: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { + mode: "longest", + padding: { a: 1, b: "a" }, +}).toArray(); + +const longestObjectsWithoutPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { + mode: "longest", +}).toArray(); + +const longestObjectsWithPartialPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { + mode: "longest", + padding: { b: "a" }, +}).toArray(); + +const maybeLongestObjects: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray(); + +interface Inputs { + a: Iterable; + b: Iterator; +} + +declare const inputs: Inputs; +const rows: { a: number; b: string; }[] = Iterator.zipKeyed(inputs).toArray(); + +Iterator.zip([[1]], { mode: "invalid" }); + +Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }); + +Iterator.zip([[1]], { mode: "shortest", padding: [1] }); + +Iterator.zip(0); + +Iterator.zipKeyed({ a: 0 }); + +const emptyKeyed: never[] = Iterator.zipKeyed({}).toArray(); +const emptyKeyedLongest: never[] = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); + +declare const unionInputs: { a: Iterable; } | { b: Iterator; }; +const unionRows: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(unionInputs).toArray(); + +// Inputs + +Iterator.zip("ab"); +Iterator.zip(["ab"]); +Iterator.zip(new Set(["ab"])); +Iterator.zipKeyed("ab"); +Iterator.zipKeyed({ a: "ab" }); +Iterator.zip([], { mode: "longest", padding: "ab" }); +Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); +Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); + +const a: [string][] = Iterator.zip([new String("ab")]).toArray(); +const b: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); +const c: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); + +const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); +const e: { a: number; }[] = d; +d[0].b; +const f: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); +const g: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); + +interface I { + readonly a: Iterable; + readonly b?: Iterator; + readonly c: Iterable | undefined; + readonly d?: undefined; +} +declare const h: I; +const i = Iterator.zipKeyed(h).toArray(); +const j: { a: number; b?: string; c?: boolean; }[] = i; +i[0].a = 2; +i[0].b = "a"; +i[0].c = true; +i[0].d; +const k: { a: number; c: boolean; }[] = i; +const l: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); + +declare const m: { a: Iterable; } | { b: Iterator; }; +const n: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(m).toArray(); +declare const o: { a: Iterable; } | { b: number; }; +Iterator.zipKeyed(o); +Iterator.zipKeyed(o, { mode: "longest" }); +Iterator.zipKeyed(o, { mode: "longest", padding: {} }); +declare const p: { a?: Iterable; } | { b: string; }; +Iterator.zipKeyed(p); +declare const q: { a: Iterable; } | { b: undefined; }; +const r: { a: number; }[] = Iterator.zipKeyed(q).toArray(); + +declare const s: unique symbol; +declare const t: { a: Iterable; [s]?: Iterable; }; +const u: { a: number; [s]?: string; }[] = Iterator.zipKeyed(t).toArray(); + +Iterator.zipKeyed({ a: [1], b: null }); +Iterator.zipKeyed({ a: [1], b: false }); +Iterator.zip([undefined]); + +declare const v: { a?: undefined; }; +const w: never[] = Iterator.zipKeyed(v).toArray(); +const x: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); +const y: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); + +function f1(a: Iterable) { + const b: { a: T; }[] = Iterator.zipKeyed({ a }).toArray(); + const c: [T][] = Iterator.zip([a]).toArray(); + return { b, c }; +} + +// Padding + +const paddingA: [Iterable, ...Iterable[]] = [[1, 2], [3]]; +const paddingB = Iterator.zip(paddingA, { mode: "longest", padding: [0] }).toArray(); +const paddingC: (number | undefined)[][] = paddingB; +const paddingD: number[][] = paddingB; + +const paddingE: Record> = { a: [1], b: [2, 3] }; +const paddingF = Iterator.zipKeyed(paddingE, { mode: "longest", padding: {} }).toArray(); +const paddingG: Record[] = paddingF; +const paddingH: Record[] = paddingF; + +declare const paddingI: Record; +const paddingJ = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: paddingI }).toArray(); +const paddingK: { a: number | undefined; b: number | undefined; }[] = paddingJ; +const paddingL: { a: number; b: number; }[] = paddingJ; + +const paddingM = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); +const paddingN: [number, string][] = paddingM; +const paddingO = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); +const paddingP: { a: number; b: string; }[] = paddingO; + +const paddingQ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); +const paddingR: [number | undefined, string | undefined][] = paddingQ; +const paddingS: [number, string][] = paddingQ; +const paddingT = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); +const paddingU: { a: number | undefined; b: string | undefined; }[] = paddingT; +const paddingV: { a: number; b: string; }[] = paddingT; + +declare const paddingW: readonly [number, string]; +const paddingX: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingW }).toArray(); +declare const paddingY: [number, string?]; +const paddingZ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY }).toArray(); +const paddingA1: [number, string][] = paddingZ; + +declare const paddingB1: [Iterable] | [Iterable, Iterable]; +const paddingC1 = Iterator.zip(paddingB1, { mode: "longest", padding: [0] }).toArray(); +const paddingD1: number[][] = paddingC1; +declare const paddingE1: { a: Iterable; } | { b: Iterable; }; +const paddingF1 = Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: 0 } }).toArray(); +const paddingG1: ({ a: number; } | { b: string; })[] = paddingF1; + +declare const paddingH1: { a: number; } | { b: string; }; +const paddingI1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: paddingH1 }).toArray(); +const paddingJ1: { a: number; b: string; }[] = paddingI1; + +const paddingK1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); +const paddingL1: { a: number; b: number; }[] = paddingK1; + +declare const paddingM1: { [K in `a${string}`]: Iterable; }; +const paddingN1 = Iterator.zipKeyed(paddingM1, { mode: "longest", padding: {} }).toArray(); +const paddingO1: { [K in `a${string}`]: number; }[] = paddingN1; + +declare const paddingP1: unique symbol; +const paddingQ1: { [paddingP1]: number; }[] = Iterator.zipKeyed({ [paddingP1]: [1] }, { mode: "longest", padding: { [paddingP1]: 0 } }).toArray(); + +declare const paddingR1: Record & { a: number; }; +const paddingS1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: paddingR1 }).toArray(); +const paddingT1: { a: number; b: number | undefined; }[] = paddingS1; +const paddingU1: { a: number; b: number; }[] = paddingS1; + +declare const paddingV1: [number] | [number, string]; +const paddingW1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingV1 }).toArray(); +const paddingX1: [number, string | undefined][] = paddingW1; +const paddingY1: [number, string][] = paddingW1; + +const paddingZ1: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); +const paddingA2: { a: number | undefined; b: number; }[] = paddingK1; + +// Own properties + +class InputsWithPrototypeMembers { + values = [1, 2]; + + get label() { + return "inputs"; + } + + describe() { + return this.label; + } +} + +const instance = new InputsWithPrototypeMembers(); +const inherited = Iterator.zipKeyed(instance).toArray(); +const inheritedStrict = Iterator.zipKeyed(instance, { mode: "strict" }).toArray(); +const inheritedLongest = Iterator.zipKeyed(instance, { mode: "longest" }).toArray(); +const inheritedPadded = Iterator.zipKeyed(instance, { mode: "longest", padding: { values: 0 } }).toArray(); + +const hiddenInputs = { values: [1, 2], label: "inputs" }; +Object.defineProperty(hiddenInputs, "label", { enumerable: false }); +const nonEnumerable = Iterator.zipKeyed(hiddenInputs).toArray(); +const nonEnumerablePadded = Iterator.zipKeyed(hiddenInputs, { mode: "longest", padding: { values: 0 } }).toArray(); + +// The same static shape can have an enumerable non-iterator property instead. +// Such inputs are accepted by the fallback and checked at runtime. +const enumerableInputs = { values: [1, 2], label: "inputs" }; +const enumerable = Iterator.zipKeyed(enumerableInputs).toArray(); + +// The array's length and methods are not enumerable own properties. +const arrayInputs = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); + +// The fallback must not claim that ignored properties exist on yielded objects. +const inheritedLabel: string = inherited[0].label; +const nonEnumerableLabel: string = nonEnumerable[0].label; + +// Precise record inference still handles symbol keys and padding. +declare const ownKey: unique symbol; +const precise: { values: number; [ownKey]: string; }[] = Iterator.zipKeyed({ values: [1], [ownKey]: ["a"] }).toArray(); +const preciseLongest: { values: number | undefined; }[] = Iterator.zipKeyed({ values: [1] }, { mode: "longest" }).toArray(); +const precisePadded: { values: number; }[] = Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: 0 } }).toArray(); +const emptyOwnProperties: never[] = Iterator.zipKeyed({}).toArray(); + +Iterator.zipKeyed(0); +Iterator.zipKeyed(null); +Iterator.zipKeyed(instance, { mode: "invalid" }); +Iterator.zipKeyed(instance, { mode: "shortest", padding: {} }); +Iterator.zipKeyed(instance, { mode: "longest", padding: 0 }); +Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: "invalid" } }); + + +//// [iteratorZip.js] +"use strict"; +const tuples = Iterator.zip([ + [1, 2], + new Set(["a", "b"]), +]).toArray(); +tuples[0][0] = 2; +const shortestTuples = Iterator.zip([[1], ["a"]], { mode: "shortest" }).toArray(); +const strictTuples = Iterator.zip([[1], ["a"]], { mode: "strict" }).toArray(); +const longestTuplesWithPadding = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [1, "a"] }).toArray(); +const longestTuplesWithoutPadding = Iterator.zip([[1], ["a"]], { mode: "longest" }).toArray(); +const longestTuplesWithPartialPadding = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [1] }).toArray(); +const maybeLongestTuples = Iterator.zip([[1], ["a"]], maybeLongestOptions).toArray(); +const empty = Iterator.zip([]).toArray(); +const emptyLongest = Iterator.zip([], { mode: "longest" }).toArray(); +const arrays = Iterator.zip(iterables).toArray(); +const longestArrays = Iterator.zip(iterables, { mode: "longest" }).toArray(); +const maybeLongestArrays = Iterator.zip(iterables, maybeLongestOptions).toArray(); +const longestArrayWithPadding = Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray(); +const objects = Iterator.zipKeyed({ + a: [1, 2], + b: new Set(["a", "b"]), + [key]: [true, false], +}).toArray(); +objects[0].a = 2; +const longestObjectsWithPadding = Iterator.zipKeyed({ a: [1], b: ["a"] }, { + mode: "longest", + padding: { a: 1, b: "a" }, +}).toArray(); +const longestObjectsWithoutPadding = Iterator.zipKeyed({ a: [1], b: ["a"] }, { + mode: "longest", +}).toArray(); +const longestObjectsWithPartialPadding = Iterator.zipKeyed({ a: [1], b: ["a"] }, { + mode: "longest", + padding: { b: "a" }, +}).toArray(); +const maybeLongestObjects = Iterator.zipKeyed({ a: [1], b: ["a"] }, maybeLongestOptions).toArray(); +const rows = Iterator.zipKeyed(inputs).toArray(); +Iterator.zip([[1]], { mode: "invalid" }); +Iterator.zip([[1], ["a"]], { mode: "longest", padding: [true] }); +Iterator.zip([[1]], { mode: "shortest", padding: [1] }); +Iterator.zip(0); +Iterator.zipKeyed({ a: 0 }); +const emptyKeyed = Iterator.zipKeyed({}).toArray(); +const emptyKeyedLongest = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); +const unionRows = Iterator.zipKeyed(unionInputs).toArray(); +// Inputs +Iterator.zip("ab"); +Iterator.zip(["ab"]); +Iterator.zip(new Set(["ab"])); +Iterator.zipKeyed("ab"); +Iterator.zipKeyed({ a: "ab" }); +Iterator.zip([], { mode: "longest", padding: "ab" }); +Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); +Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); +const a = Iterator.zip([new String("ab")]).toArray(); +const b = Iterator.zipKeyed({ a: new String("ab") }).toArray(); +const c = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); +const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); +const e = d; +d[0].b; +const f = Iterator.zipKeyed({ a: undefined }).toArray(); +const g = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); +const i = Iterator.zipKeyed(h).toArray(); +const j = i; +i[0].a = 2; +i[0].b = "a"; +i[0].c = true; +i[0].d; +const k = i; +const l = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); +const n = Iterator.zipKeyed(m).toArray(); +Iterator.zipKeyed(o); +Iterator.zipKeyed(o, { mode: "longest" }); +Iterator.zipKeyed(o, { mode: "longest", padding: {} }); +Iterator.zipKeyed(p); +const r = Iterator.zipKeyed(q).toArray(); +const u = Iterator.zipKeyed(t).toArray(); +Iterator.zipKeyed({ a: [1], b: null }); +Iterator.zipKeyed({ a: [1], b: false }); +Iterator.zip([undefined]); +const w = Iterator.zipKeyed(v).toArray(); +const x = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); +const y = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); +function f1(a) { + const b = Iterator.zipKeyed({ a }).toArray(); + const c = Iterator.zip([a]).toArray(); + return { b, c }; +} +// Padding +const paddingA = [[1, 2], [3]]; +const paddingB = Iterator.zip(paddingA, { mode: "longest", padding: [0] }).toArray(); +const paddingC = paddingB; +const paddingD = paddingB; +const paddingE = { a: [1], b: [2, 3] }; +const paddingF = Iterator.zipKeyed(paddingE, { mode: "longest", padding: {} }).toArray(); +const paddingG = paddingF; +const paddingH = paddingF; +const paddingJ = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: paddingI }).toArray(); +const paddingK = paddingJ; +const paddingL = paddingJ; +const paddingM = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); +const paddingN = paddingM; +const paddingO = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); +const paddingP = paddingO; +const paddingQ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); +const paddingR = paddingQ; +const paddingS = paddingQ; +const paddingT = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); +const paddingU = paddingT; +const paddingV = paddingT; +const paddingX = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingW }).toArray(); +const paddingZ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY }).toArray(); +const paddingA1 = paddingZ; +const paddingC1 = Iterator.zip(paddingB1, { mode: "longest", padding: [0] }).toArray(); +const paddingD1 = paddingC1; +const paddingF1 = Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: 0 } }).toArray(); +const paddingG1 = paddingF1; +const paddingI1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: paddingH1 }).toArray(); +const paddingJ1 = paddingI1; +const paddingK1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); +const paddingL1 = paddingK1; +const paddingN1 = Iterator.zipKeyed(paddingM1, { mode: "longest", padding: {} }).toArray(); +const paddingO1 = paddingN1; +const paddingQ1 = Iterator.zipKeyed({ [paddingP1]: [1] }, { mode: "longest", padding: { [paddingP1]: 0 } }).toArray(); +const paddingS1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: paddingR1 }).toArray(); +const paddingT1 = paddingS1; +const paddingU1 = paddingS1; +const paddingW1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingV1 }).toArray(); +const paddingX1 = paddingW1; +const paddingY1 = paddingW1; +const paddingZ1 = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); +const paddingA2 = paddingK1; +// Own properties +class InputsWithPrototypeMembers { + values = [1, 2]; + get label() { + return "inputs"; + } + describe() { + return this.label; + } +} +const instance = new InputsWithPrototypeMembers(); +const inherited = Iterator.zipKeyed(instance).toArray(); +const inheritedStrict = Iterator.zipKeyed(instance, { mode: "strict" }).toArray(); +const inheritedLongest = Iterator.zipKeyed(instance, { mode: "longest" }).toArray(); +const inheritedPadded = Iterator.zipKeyed(instance, { mode: "longest", padding: { values: 0 } }).toArray(); +const hiddenInputs = { values: [1, 2], label: "inputs" }; +Object.defineProperty(hiddenInputs, "label", { enumerable: false }); +const nonEnumerable = Iterator.zipKeyed(hiddenInputs).toArray(); +const nonEnumerablePadded = Iterator.zipKeyed(hiddenInputs, { mode: "longest", padding: { values: 0 } }).toArray(); +// The same static shape can have an enumerable non-iterator property instead. +// Such inputs are accepted by the fallback and checked at runtime. +const enumerableInputs = { values: [1, 2], label: "inputs" }; +const enumerable = Iterator.zipKeyed(enumerableInputs).toArray(); +// The array's length and methods are not enumerable own properties. +const arrayInputs = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); +// The fallback must not claim that ignored properties exist on yielded objects. +const inheritedLabel = inherited[0].label; +const nonEnumerableLabel = nonEnumerable[0].label; +const precise = Iterator.zipKeyed({ values: [1], [ownKey]: ["a"] }).toArray(); +const preciseLongest = Iterator.zipKeyed({ values: [1] }, { mode: "longest" }).toArray(); +const precisePadded = Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: 0 } }).toArray(); +const emptyOwnProperties = Iterator.zipKeyed({}).toArray(); +Iterator.zipKeyed(0); +Iterator.zipKeyed(null); +Iterator.zipKeyed(instance, { mode: "invalid" }); +Iterator.zipKeyed(instance, { mode: "shortest", padding: {} }); +Iterator.zipKeyed(instance, { mode: "longest", padding: 0 }); +Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: "invalid" } }); + + +//// [iteratorZip.d.ts] +declare const key: unique symbol; +declare const tuples: [number, string][]; +declare const shortestTuples: [number, string][]; +declare const strictTuples: [number, string][]; +declare const longestTuplesWithPadding: [number, string][]; +declare const longestTuplesWithoutPadding: [number | undefined, string | undefined][]; +declare const longestTuplesWithPartialPadding: [number | undefined, string | undefined][]; +declare const maybeLongestOptions: { + mode: "shortest"; +} | { + mode: "longest"; +}; +declare const maybeLongestTuples: [number | undefined, string | undefined][]; +declare const empty: never[]; +declare const emptyLongest: never[]; +declare const iterables: Iterable>; +declare const arrays: number[][]; +declare const longestArrays: (number | undefined)[][]; +declare const maybeLongestArrays: (number | undefined)[][]; +declare const iterableArray: Iterable[]; +declare const longestArrayWithPadding: (number | undefined)[][]; +declare const objects: { + a: number; + b: string; + [key]: boolean; +}[]; +declare const longestObjectsWithPadding: { + a: number; + b: string; +}[]; +declare const longestObjectsWithoutPadding: { + a: number | undefined; + b: string | undefined; +}[]; +declare const longestObjectsWithPartialPadding: { + a: number | undefined; + b: string | undefined; +}[]; +declare const maybeLongestObjects: { + a: number | undefined; + b: string | undefined; +}[]; +interface Inputs { + a: Iterable; + b: Iterator; +} +declare const inputs: Inputs; +declare const rows: { + a: number; + b: string; +}[]; +declare const emptyKeyed: never[]; +declare const emptyKeyedLongest: never[]; +declare const unionInputs: { + a: Iterable; +} | { + b: Iterator; +}; +declare const unionRows: ({ + a: number; +} | { + b: string; +})[]; +declare const a: [string][]; +declare const b: { + a: string; +}[]; +declare const c: (string | undefined)[][]; +declare const d: { + a: number; +}[]; +declare const e: { + a: number; +}[]; +declare const f: never[]; +declare const g: never[]; +interface I { + readonly a: Iterable; + readonly b?: Iterator; + readonly c: Iterable | undefined; + readonly d?: undefined; +} +declare const h: I; +declare const i: { + a: number; + b?: string; + c?: boolean; +}[]; +declare const j: { + a: number; + b?: string; + c?: boolean; +}[]; +declare const k: { + a: number; + c: boolean; +}[]; +declare const l: { + a: number | undefined; + b?: string | undefined; + c?: boolean | undefined; +}[]; +declare const m: { + a: Iterable; +} | { + b: Iterator; +}; +declare const n: ({ + a: number; +} | { + b: string; +})[]; +declare const o: { + a: Iterable; +} | { + b: number; +}; +declare const p: { + a?: Iterable; +} | { + b: string; +}; +declare const q: { + a: Iterable; +} | { + b: undefined; +}; +declare const r: { + a: number; +}[]; +declare const s: unique symbol; +declare const t: { + a: Iterable; + [s]?: Iterable; +}; +declare const u: { + a: number; + [s]?: string; +}[]; +declare const v: { + a?: undefined; +}; +declare const w: never[]; +declare const x: { + a: number; +}[]; +declare const y: { + a: number | undefined; +}[]; +declare function f1(a: Iterable): { + b: { + a: T; + }[]; + c: [T][]; +}; +declare const paddingA: [Iterable, ...Iterable[]]; +declare const paddingB: [number, ...(number | undefined)[]][]; +declare const paddingC: (number | undefined)[][]; +declare const paddingD: number[][]; +declare const paddingE: Record>; +declare const paddingF: { + [x: string]: number | undefined; +}[]; +declare const paddingG: Record[]; +declare const paddingH: Record[]; +declare const paddingI: Record; +declare const paddingJ: { + a: number | undefined; + b: number | undefined; +}[]; +declare const paddingK: { + a: number | undefined; + b: number | undefined; +}[]; +declare const paddingL: { + a: number; + b: number; +}[]; +declare const paddingM: [number, string][]; +declare const paddingN: [number, string][]; +declare const paddingO: { + a: number; + b: string; +}[]; +declare const paddingP: { + a: number; + b: string; +}[]; +declare const paddingQ: [number, string | undefined][]; +declare const paddingR: [number | undefined, string | undefined][]; +declare const paddingS: [number, string][]; +declare const paddingT: { + a: number; + b: string | undefined; +}[]; +declare const paddingU: { + a: number | undefined; + b: string | undefined; +}[]; +declare const paddingV: { + a: number; + b: string; +}[]; +declare const paddingW: readonly [number, string]; +declare const paddingX: [number, string][]; +declare const paddingY: [number, string?]; +declare const paddingZ: [number, string | undefined][]; +declare const paddingA1: [number, string][]; +declare const paddingB1: [Iterable] | [Iterable, Iterable]; +declare const paddingC1: ([number] | [number, number | undefined])[]; +declare const paddingD1: number[][]; +declare const paddingE1: { + a: Iterable; +} | { + b: Iterable; +}; +declare const paddingF1: ({ + a: number; +} | { + b: string | undefined; +})[]; +declare const paddingG1: ({ + a: number; +} | { + b: string; +})[]; +declare const paddingH1: { + a: number; +} | { + b: string; +}; +declare const paddingI1: { + a: number | undefined; + b: string | undefined; +}[]; +declare const paddingJ1: { + a: number; + b: string; +}[]; +declare const paddingK1: { + a: number | undefined; + b: number; +}[]; +declare const paddingL1: { + a: number; + b: number; +}[]; +declare const paddingM1: { + [K in `a${string}`]: Iterable; +}; +declare const paddingN1: { + [x: `a${string}`]: number | undefined; +}[]; +declare const paddingO1: { + [K in `a${string}`]: number; +}[]; +declare const paddingP1: unique symbol; +declare const paddingQ1: { + [paddingP1]: number; +}[]; +declare const paddingR1: Record & { + a: number; +}; +declare const paddingS1: { + a: number; + b: number | undefined; +}[]; +declare const paddingT1: { + a: number; + b: number | undefined; +}[]; +declare const paddingU1: { + a: number; + b: number; +}[]; +declare const paddingV1: [number] | [number, string]; +declare const paddingW1: [number, string | undefined][]; +declare const paddingX1: [number, string | undefined][]; +declare const paddingY1: [number, string][]; +declare const paddingZ1: [number | undefined, number][]; +declare const paddingA2: { + a: number | undefined; + b: number; +}[]; +declare class InputsWithPrototypeMembers { + values: number[]; + get label(): string; + describe(): string; +} +declare const instance: InputsWithPrototypeMembers; +declare const inherited: Record[]; +declare const inheritedStrict: Record[]; +declare const inheritedLongest: Record[]; +declare const inheritedPadded: Record[]; +declare const hiddenInputs: { + values: number[]; + label: string; +}; +declare const nonEnumerable: Record[]; +declare const nonEnumerablePadded: Record[]; +declare const enumerableInputs: { + values: number[]; + label: string; +}; +declare const enumerable: Record[]; +declare const arrayInputs: Record[]; +declare const inheritedLabel: string; +declare const nonEnumerableLabel: string; +declare const ownKey: unique symbol; +declare const precise: { + values: number; + [ownKey]: string; +}[]; +declare const preciseLongest: { + values: number | undefined; +}[]; +declare const precisePadded: { + values: number; +}[]; +declare const emptyOwnProperties: never[]; diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).symbols b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).symbols new file mode 100644 index 0000000000000..3314b80fc616e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).symbols @@ -0,0 +1,1368 @@ +//// [tests/cases/compiler/iteratorZip.ts] //// + +=== iteratorZip.ts === +declare const key: unique symbol; +>key : Symbol(key, Decl(iteratorZip.ts, 0, 13)) + +const tuples: [number, string][] = Iterator.zip([ +>tuples : Symbol(tuples, Decl(iteratorZip.ts, 2, 5)) +>Iterator.zip([ [1, 2], new Set(["a", "b"]),] as const).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) + + [1, 2], + new Set(["a", "b"]), +>Set : Symbol(Set, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) + +] as const).toArray(); +>const : Symbol(const) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +tuples[0][0] = 2; +>tuples : Symbol(tuples, Decl(iteratorZip.ts, 2, 5)) +>0 : Symbol(0) + +const shortestTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray(); +>shortestTuples : Symbol(shortestTuples, Decl(iteratorZip.ts, 9, 5)) +>Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>const : Symbol(const) +>mode : Symbol(mode, Decl(iteratorZip.ts, 9, 80)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const strictTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray(); +>strictTuples : Symbol(strictTuples, Decl(iteratorZip.ts, 10, 5)) +>Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>const : Symbol(const) +>mode : Symbol(mode, Decl(iteratorZip.ts, 10, 78)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const longestTuplesWithPadding: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray(); +>longestTuplesWithPadding : Symbol(longestTuplesWithPadding, Decl(iteratorZip.ts, 11, 5)) +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>const : Symbol(const) +>mode : Symbol(mode, Decl(iteratorZip.ts, 11, 90)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 11, 107)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const longestTuplesWithoutPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray(); +>longestTuplesWithoutPadding : Symbol(longestTuplesWithoutPadding, Decl(iteratorZip.ts, 12, 5)) +>Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>const : Symbol(const) +>mode : Symbol(mode, Decl(iteratorZip.ts, 12, 117)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const longestTuplesWithPartialPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray(); +>longestTuplesWithPartialPadding : Symbol(longestTuplesWithPartialPadding, Decl(iteratorZip.ts, 13, 5)) +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>const : Symbol(const) +>mode : Symbol(mode, Decl(iteratorZip.ts, 13, 121)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 13, 138)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const maybeLongestOptions: { mode: "shortest"; } | { mode: "longest"; }; +>maybeLongestOptions : Symbol(maybeLongestOptions, Decl(iteratorZip.ts, 15, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 15, 36)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 15, 60)) + +const maybeLongestTuples: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray(); +>maybeLongestTuples : Symbol(maybeLongestTuples, Decl(iteratorZip.ts, 16, 5)) +>Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>const : Symbol(const) +>maybeLongestOptions : Symbol(maybeLongestOptions, Decl(iteratorZip.ts, 15, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const empty: never[] = Iterator.zip([]).toArray(); +>empty : Symbol(empty, Decl(iteratorZip.ts, 18, 5)) +>Iterator.zip([]).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const emptyLongest: never[] = Iterator.zip([], { mode: "longest" }).toArray(); +>emptyLongest : Symbol(emptyLongest, Decl(iteratorZip.ts, 19, 5)) +>Iterator.zip([], { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZip.ts, 19, 48)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const iterables: Iterable>; +>iterables : Symbol(iterables, Decl(iteratorZip.ts, 21, 13)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + +const arrays: number[][] = Iterator.zip(iterables).toArray(); +>arrays : Symbol(arrays, Decl(iteratorZip.ts, 22, 5)) +>Iterator.zip(iterables).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>iterables : Symbol(iterables, Decl(iteratorZip.ts, 21, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const longestArrays: (number | undefined)[][] = Iterator.zip(iterables, { mode: "longest" }).toArray(); +>longestArrays : Symbol(longestArrays, Decl(iteratorZip.ts, 23, 5)) +>Iterator.zip(iterables, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>iterables : Symbol(iterables, Decl(iteratorZip.ts, 21, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 23, 73)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const maybeLongestArrays: (number | undefined)[][] = Iterator.zip(iterables, maybeLongestOptions).toArray(); +>maybeLongestArrays : Symbol(maybeLongestArrays, Decl(iteratorZip.ts, 24, 5)) +>Iterator.zip(iterables, maybeLongestOptions).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>iterables : Symbol(iterables, Decl(iteratorZip.ts, 21, 13)) +>maybeLongestOptions : Symbol(maybeLongestOptions, Decl(iteratorZip.ts, 15, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const iterableArray: Iterable[]; +>iterableArray : Symbol(iterableArray, Decl(iteratorZip.ts, 26, 13)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + +const longestArrayWithPadding: (number | undefined)[][] = Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray(); +>longestArrayWithPadding : Symbol(longestArrayWithPadding, Decl(iteratorZip.ts, 27, 5)) +>Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>iterableArray : Symbol(iterableArray, Decl(iteratorZip.ts, 26, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 27, 87)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 27, 104)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ +>objects : Symbol(objects, Decl(iteratorZip.ts, 29, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 29, 16)) +>b : Symbol(b, Decl(iteratorZip.ts, 29, 27)) +>[key] : Symbol([key], Decl(iteratorZip.ts, 29, 38)) +>key : Symbol(key, Decl(iteratorZip.ts, 0, 13)) +>Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) + + a: [1, 2], +>a : Symbol(a, Decl(iteratorZip.ts, 29, 80)) + + b: new Set(["a", "b"]), +>b : Symbol(b, Decl(iteratorZip.ts, 30, 14)) +>Set : Symbol(Set, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) + + [key]: [true, false], +>[key] : Symbol([key], Decl(iteratorZip.ts, 31, 27)) +>key : Symbol(key, Decl(iteratorZip.ts, 0, 13)) + +} as const).toArray(); +>const : Symbol(const) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +objects[0].a = 2; +>objects[0].a : Symbol(a, Decl(iteratorZip.ts, 29, 16)) +>objects : Symbol(objects, Decl(iteratorZip.ts, 29, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 29, 16)) + +const longestObjectsWithPadding: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +>longestObjectsWithPadding : Symbol(longestObjectsWithPadding, Decl(iteratorZip.ts, 37, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 37, 34)) +>b : Symbol(b, Decl(iteratorZip.ts, 37, 45)) +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 37, 82)) +>b : Symbol(b, Decl(iteratorZip.ts, 37, 90)) +>const : Symbol(const) + + mode: "longest", +>mode : Symbol(mode, Decl(iteratorZip.ts, 37, 113)) + + padding: { a: 1, b: "a" }, +>padding : Symbol(padding, Decl(iteratorZip.ts, 38, 20)) +>a : Symbol(a, Decl(iteratorZip.ts, 39, 14)) +>b : Symbol(b, Decl(iteratorZip.ts, 39, 20)) + +}).toArray(); +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const longestObjectsWithoutPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +>longestObjectsWithoutPadding : Symbol(longestObjectsWithoutPadding, Decl(iteratorZip.ts, 42, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 42, 37)) +>b : Symbol(b, Decl(iteratorZip.ts, 42, 60)) +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 42, 109)) +>b : Symbol(b, Decl(iteratorZip.ts, 42, 117)) +>const : Symbol(const) + + mode: "longest", +>mode : Symbol(mode, Decl(iteratorZip.ts, 42, 140)) + +}).toArray(); +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const longestObjectsWithPartialPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +>longestObjectsWithPartialPadding : Symbol(longestObjectsWithPartialPadding, Decl(iteratorZip.ts, 46, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 46, 41)) +>b : Symbol(b, Decl(iteratorZip.ts, 46, 64)) +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 46, 113)) +>b : Symbol(b, Decl(iteratorZip.ts, 46, 121)) +>const : Symbol(const) + + mode: "longest", +>mode : Symbol(mode, Decl(iteratorZip.ts, 46, 144)) + + padding: { b: "a" }, +>padding : Symbol(padding, Decl(iteratorZip.ts, 47, 20)) +>b : Symbol(b, Decl(iteratorZip.ts, 48, 14)) + +}).toArray(); +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const maybeLongestObjects: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray(); +>maybeLongestObjects : Symbol(maybeLongestObjects, Decl(iteratorZip.ts, 51, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 51, 28)) +>b : Symbol(b, Decl(iteratorZip.ts, 51, 51)) +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 51, 100)) +>b : Symbol(b, Decl(iteratorZip.ts, 51, 108)) +>const : Symbol(const) +>maybeLongestOptions : Symbol(maybeLongestOptions, Decl(iteratorZip.ts, 15, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +interface Inputs { +>Inputs : Symbol(Inputs, Decl(iteratorZip.ts, 51, 161)) + + a: Iterable; +>a : Symbol(Inputs.a, Decl(iteratorZip.ts, 53, 18)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + + b: Iterator; +>b : Symbol(Inputs.b, Decl(iteratorZip.ts, 54, 24)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +} + +declare const inputs: Inputs; +>inputs : Symbol(inputs, Decl(iteratorZip.ts, 58, 13)) +>Inputs : Symbol(Inputs, Decl(iteratorZip.ts, 51, 161)) + +const rows: { a: number; b: string; }[] = Iterator.zipKeyed(inputs).toArray(); +>rows : Symbol(rows, Decl(iteratorZip.ts, 59, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 59, 13)) +>b : Symbol(b, Decl(iteratorZip.ts, 59, 24)) +>Iterator.zipKeyed(inputs).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>inputs : Symbol(inputs, Decl(iteratorZip.ts, 58, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +Iterator.zip([[1]], { mode: "invalid" }); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZip.ts, 61, 21)) + +Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>const : Symbol(const) +>mode : Symbol(mode, Decl(iteratorZip.ts, 63, 37)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 63, 54)) + +Iterator.zip([[1]], { mode: "shortest", padding: [1] }); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZip.ts, 65, 21)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 65, 39)) + +Iterator.zip(0); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) + +Iterator.zipKeyed({ a: 0 }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 69, 19)) + +const emptyKeyed: never[] = Iterator.zipKeyed({}).toArray(); +>emptyKeyed : Symbol(emptyKeyed, Decl(iteratorZip.ts, 71, 5)) +>Iterator.zipKeyed({}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const emptyKeyedLongest: never[] = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); +>emptyKeyedLongest : Symbol(emptyKeyedLongest, Decl(iteratorZip.ts, 72, 5)) +>Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 72, 58)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 72, 75)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const unionInputs: { a: Iterable; } | { b: Iterator; }; +>unionInputs : Symbol(unionInputs, Decl(iteratorZip.ts, 74, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 74, 28)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>b : Symbol(b, Decl(iteratorZip.ts, 74, 55)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) + +const unionRows: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(unionInputs).toArray(); +>unionRows : Symbol(unionRows, Decl(iteratorZip.ts, 75, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 75, 19)) +>b : Symbol(b, Decl(iteratorZip.ts, 75, 36)) +>Iterator.zipKeyed(unionInputs).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>unionInputs : Symbol(unionInputs, Decl(iteratorZip.ts, 74, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +// Inputs + +Iterator.zip("ab"); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) + +Iterator.zip(["ab"]); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) + +Iterator.zip(new Set(["ab"])); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Set : Symbol(Set, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) + +Iterator.zipKeyed("ab"); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) + +Iterator.zipKeyed({ a: "ab" }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 83, 19)) + +Iterator.zip([], { mode: "longest", padding: "ab" }); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZip.ts, 84, 18)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 84, 35)) + +Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZip.ts, 85, 23)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 85, 40)) + +Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 86, 23)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 86, 40)) + +const a: [string][] = Iterator.zip([new String("ab")]).toArray(); +>a : Symbol(a, Decl(iteratorZip.ts, 88, 5)) +>Iterator.zip([new String("ab")]).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const b: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); +>b : Symbol(b, Decl(iteratorZip.ts, 89, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 89, 10)) +>Iterator.zipKeyed({ a: new String("ab") }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 89, 47)) +>String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const c: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); +>c : Symbol(c, Decl(iteratorZip.ts, 90, 5)) +>Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZip.ts, 90, 59)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 90, 76)) +>String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); +>d : Symbol(d, Decl(iteratorZip.ts, 92, 5)) +>Iterator.zipKeyed({ a: [1], b: undefined }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 92, 29)) +>b : Symbol(b, Decl(iteratorZip.ts, 92, 37)) +>undefined : Symbol(undefined) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const e: { a: number; }[] = d; +>e : Symbol(e, Decl(iteratorZip.ts, 93, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 93, 10)) +>d : Symbol(d, Decl(iteratorZip.ts, 92, 5)) + +d[0].b; +>d : Symbol(d, Decl(iteratorZip.ts, 92, 5)) + +const f: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); +>f : Symbol(f, Decl(iteratorZip.ts, 95, 5)) +>Iterator.zipKeyed({ a: undefined }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 95, 38)) +>undefined : Symbol(undefined) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const g: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); +>g : Symbol(g, Decl(iteratorZip.ts, 96, 5)) +>Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 96, 38)) +>undefined : Symbol(undefined) +>mode : Symbol(mode, Decl(iteratorZip.ts, 96, 56)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 96, 73)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +interface I { +>I : Symbol(I, Decl(iteratorZip.ts, 96, 99)) + + readonly a: Iterable; +>a : Symbol(I.a, Decl(iteratorZip.ts, 98, 13)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + + readonly b?: Iterator; +>b : Symbol(I.b, Decl(iteratorZip.ts, 99, 33)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) + + readonly c: Iterable | undefined; +>c : Symbol(I.c, Decl(iteratorZip.ts, 100, 34)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + + readonly d?: undefined; +>d : Symbol(I.d, Decl(iteratorZip.ts, 101, 46)) +} +declare const h: I; +>h : Symbol(h, Decl(iteratorZip.ts, 104, 13)) +>I : Symbol(I, Decl(iteratorZip.ts, 96, 99)) + +const i = Iterator.zipKeyed(h).toArray(); +>i : Symbol(i, Decl(iteratorZip.ts, 105, 5)) +>Iterator.zipKeyed(h).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>h : Symbol(h, Decl(iteratorZip.ts, 104, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const j: { a: number; b?: string; c?: boolean; }[] = i; +>j : Symbol(j, Decl(iteratorZip.ts, 106, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 106, 10)) +>b : Symbol(b, Decl(iteratorZip.ts, 106, 21)) +>c : Symbol(c, Decl(iteratorZip.ts, 106, 33)) +>i : Symbol(i, Decl(iteratorZip.ts, 105, 5)) + +i[0].a = 2; +>i[0].a : Symbol(a, Decl(iteratorZip.ts, 98, 13)) +>i : Symbol(i, Decl(iteratorZip.ts, 105, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 98, 13)) + +i[0].b = "a"; +>i[0].b : Symbol(b, Decl(iteratorZip.ts, 99, 33)) +>i : Symbol(i, Decl(iteratorZip.ts, 105, 5)) +>b : Symbol(b, Decl(iteratorZip.ts, 99, 33)) + +i[0].c = true; +>i[0].c : Symbol(c, Decl(iteratorZip.ts, 100, 34)) +>i : Symbol(i, Decl(iteratorZip.ts, 105, 5)) +>c : Symbol(c, Decl(iteratorZip.ts, 100, 34)) + +i[0].d; +>i : Symbol(i, Decl(iteratorZip.ts, 105, 5)) + +const k: { a: number; c: boolean; }[] = i; +>k : Symbol(k, Decl(iteratorZip.ts, 111, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 111, 10)) +>c : Symbol(c, Decl(iteratorZip.ts, 111, 21)) +>i : Symbol(i, Decl(iteratorZip.ts, 105, 5)) + +const l: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); +>l : Symbol(l, Decl(iteratorZip.ts, 112, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 112, 10)) +>b : Symbol(b, Decl(iteratorZip.ts, 112, 33)) +>c : Symbol(c, Decl(iteratorZip.ts, 112, 57)) +>Iterator.zipKeyed(h, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>h : Symbol(h, Decl(iteratorZip.ts, 104, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 112, 111)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const m: { a: Iterable; } | { b: Iterator; }; +>m : Symbol(m, Decl(iteratorZip.ts, 114, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 114, 18)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>b : Symbol(b, Decl(iteratorZip.ts, 114, 45)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) + +const n: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(m).toArray(); +>n : Symbol(n, Decl(iteratorZip.ts, 115, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 115, 11)) +>b : Symbol(b, Decl(iteratorZip.ts, 115, 28)) +>Iterator.zipKeyed(m).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>m : Symbol(m, Decl(iteratorZip.ts, 114, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const o: { a: Iterable; } | { b: number; }; +>o : Symbol(o, Decl(iteratorZip.ts, 116, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 116, 18)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>b : Symbol(b, Decl(iteratorZip.ts, 116, 45)) + +Iterator.zipKeyed(o); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>o : Symbol(o, Decl(iteratorZip.ts, 116, 13)) + +Iterator.zipKeyed(o, { mode: "longest" }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>o : Symbol(o, Decl(iteratorZip.ts, 116, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 118, 22)) + +Iterator.zipKeyed(o, { mode: "longest", padding: {} }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>o : Symbol(o, Decl(iteratorZip.ts, 116, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 119, 22)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 119, 39)) + +declare const p: { a?: Iterable; } | { b: string; }; +>p : Symbol(p, Decl(iteratorZip.ts, 120, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 120, 18)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>b : Symbol(b, Decl(iteratorZip.ts, 120, 46)) + +Iterator.zipKeyed(p); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>p : Symbol(p, Decl(iteratorZip.ts, 120, 13)) + +declare const q: { a: Iterable; } | { b: undefined; }; +>q : Symbol(q, Decl(iteratorZip.ts, 122, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 122, 18)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>b : Symbol(b, Decl(iteratorZip.ts, 122, 45)) + +const r: { a: number; }[] = Iterator.zipKeyed(q).toArray(); +>r : Symbol(r, Decl(iteratorZip.ts, 123, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 123, 10)) +>Iterator.zipKeyed(q).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>q : Symbol(q, Decl(iteratorZip.ts, 122, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const s: unique symbol; +>s : Symbol(s, Decl(iteratorZip.ts, 125, 13)) + +declare const t: { a: Iterable; [s]?: Iterable; }; +>t : Symbol(t, Decl(iteratorZip.ts, 126, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 126, 18)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>[s] : Symbol([s], Decl(iteratorZip.ts, 126, 39)) +>s : Symbol(s, Decl(iteratorZip.ts, 125, 13)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + +const u: { a: number; [s]?: string; }[] = Iterator.zipKeyed(t).toArray(); +>u : Symbol(u, Decl(iteratorZip.ts, 127, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 127, 10)) +>[s] : Symbol([s], Decl(iteratorZip.ts, 127, 21)) +>s : Symbol(s, Decl(iteratorZip.ts, 125, 13)) +>Iterator.zipKeyed(t).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>t : Symbol(t, Decl(iteratorZip.ts, 126, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +Iterator.zipKeyed({ a: [1], b: null }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 129, 19)) +>b : Symbol(b, Decl(iteratorZip.ts, 129, 27)) + +Iterator.zipKeyed({ a: [1], b: false }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 130, 19)) +>b : Symbol(b, Decl(iteratorZip.ts, 130, 27)) + +Iterator.zip([undefined]); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>undefined : Symbol(undefined) + +declare const v: { a?: undefined; }; +>v : Symbol(v, Decl(iteratorZip.ts, 133, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 133, 18)) + +const w: never[] = Iterator.zipKeyed(v).toArray(); +>w : Symbol(w, Decl(iteratorZip.ts, 134, 5)) +>Iterator.zipKeyed(v).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>v : Symbol(v, Decl(iteratorZip.ts, 133, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const x: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); +>x : Symbol(x, Decl(iteratorZip.ts, 135, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 135, 10)) +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 135, 47)) +>b : Symbol(b, Decl(iteratorZip.ts, 135, 55)) +>undefined : Symbol(undefined) +>mode : Symbol(mode, Decl(iteratorZip.ts, 135, 73)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 135, 90)) +>a : Symbol(a, Decl(iteratorZip.ts, 135, 101)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const y: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); +>y : Symbol(y, Decl(iteratorZip.ts, 136, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 136, 10)) +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 136, 59)) +>b : Symbol(b, Decl(iteratorZip.ts, 136, 67)) +>undefined : Symbol(undefined) +>mode : Symbol(mode, Decl(iteratorZip.ts, 136, 85)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +function f1(a: Iterable) { +>f1 : Symbol(f1, Decl(iteratorZip.ts, 136, 115)) +>T : Symbol(T, Decl(iteratorZip.ts, 138, 12)) +>a : Symbol(a, Decl(iteratorZip.ts, 138, 15)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>T : Symbol(T, Decl(iteratorZip.ts, 138, 12)) + + const b: { a: T; }[] = Iterator.zipKeyed({ a }).toArray(); +>b : Symbol(b, Decl(iteratorZip.ts, 139, 9)) +>a : Symbol(a, Decl(iteratorZip.ts, 139, 14)) +>T : Symbol(T, Decl(iteratorZip.ts, 138, 12)) +>Iterator.zipKeyed({ a }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 139, 46)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + + const c: [T][] = Iterator.zip([a]).toArray(); +>c : Symbol(c, Decl(iteratorZip.ts, 140, 9)) +>T : Symbol(T, Decl(iteratorZip.ts, 138, 12)) +>Iterator.zip([a]).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>a : Symbol(a, Decl(iteratorZip.ts, 138, 15)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + + return { b, c }; +>b : Symbol(b, Decl(iteratorZip.ts, 141, 12)) +>c : Symbol(c, Decl(iteratorZip.ts, 141, 15)) +} + +// Padding + +const paddingA: [Iterable, ...Iterable[]] = [[1, 2], [3]]; +>paddingA : Symbol(paddingA, Decl(iteratorZip.ts, 146, 5)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + +const paddingB = Iterator.zip(paddingA, { mode: "longest", padding: [0] }).toArray(); +>paddingB : Symbol(paddingB, Decl(iteratorZip.ts, 147, 5)) +>Iterator.zip(paddingA, { mode: "longest", padding: [0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>paddingA : Symbol(paddingA, Decl(iteratorZip.ts, 146, 5)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 147, 41)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 147, 58)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const paddingC: (number | undefined)[][] = paddingB; +>paddingC : Symbol(paddingC, Decl(iteratorZip.ts, 148, 5)) +>paddingB : Symbol(paddingB, Decl(iteratorZip.ts, 147, 5)) + +const paddingD: number[][] = paddingB; +>paddingD : Symbol(paddingD, Decl(iteratorZip.ts, 149, 5)) +>paddingB : Symbol(paddingB, Decl(iteratorZip.ts, 147, 5)) + +const paddingE: Record> = { a: [1], b: [2, 3] }; +>paddingE : Symbol(paddingE, Decl(iteratorZip.ts, 151, 5)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 151, 52)) +>b : Symbol(b, Decl(iteratorZip.ts, 151, 60)) + +const paddingF = Iterator.zipKeyed(paddingE, { mode: "longest", padding: {} }).toArray(); +>paddingF : Symbol(paddingF, Decl(iteratorZip.ts, 152, 5)) +>Iterator.zipKeyed(paddingE, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>paddingE : Symbol(paddingE, Decl(iteratorZip.ts, 151, 5)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 152, 46)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 152, 63)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const paddingG: Record[] = paddingF; +>paddingG : Symbol(paddingG, Decl(iteratorZip.ts, 153, 5)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>paddingF : Symbol(paddingF, Decl(iteratorZip.ts, 152, 5)) + +const paddingH: Record[] = paddingF; +>paddingH : Symbol(paddingH, Decl(iteratorZip.ts, 154, 5)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>paddingF : Symbol(paddingF, Decl(iteratorZip.ts, 152, 5)) + +declare const paddingI: Record; +>paddingI : Symbol(paddingI, Decl(iteratorZip.ts, 156, 13)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) + +const paddingJ = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: paddingI }).toArray(); +>paddingJ : Symbol(paddingJ, Decl(iteratorZip.ts, 157, 5)) +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: paddingI }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 157, 36)) +>b : Symbol(b, Decl(iteratorZip.ts, 157, 44)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 157, 59)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 157, 76)) +>paddingI : Symbol(paddingI, Decl(iteratorZip.ts, 156, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const paddingK: { a: number | undefined; b: number | undefined; }[] = paddingJ; +>paddingK : Symbol(paddingK, Decl(iteratorZip.ts, 158, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 158, 17)) +>b : Symbol(b, Decl(iteratorZip.ts, 158, 40)) +>paddingJ : Symbol(paddingJ, Decl(iteratorZip.ts, 157, 5)) + +const paddingL: { a: number; b: number; }[] = paddingJ; +>paddingL : Symbol(paddingL, Decl(iteratorZip.ts, 159, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 159, 17)) +>b : Symbol(b, Decl(iteratorZip.ts, 159, 28)) +>paddingJ : Symbol(paddingJ, Decl(iteratorZip.ts, 157, 5)) + +const paddingM = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); +>paddingM : Symbol(paddingM, Decl(iteratorZip.ts, 161, 5)) +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZip.ts, 161, 45)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 161, 62)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const paddingN: [number, string][] = paddingM; +>paddingN : Symbol(paddingN, Decl(iteratorZip.ts, 162, 5)) +>paddingM : Symbol(paddingM, Decl(iteratorZip.ts, 161, 5)) + +const paddingO = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); +>paddingO : Symbol(paddingO, Decl(iteratorZip.ts, 163, 5)) +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 163, 36)) +>b : Symbol(b, Decl(iteratorZip.ts, 163, 44)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 163, 58)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 163, 75)) +>a : Symbol(a, Decl(iteratorZip.ts, 163, 86)) +>b : Symbol(b, Decl(iteratorZip.ts, 163, 92)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const paddingP: { a: number; b: string; }[] = paddingO; +>paddingP : Symbol(paddingP, Decl(iteratorZip.ts, 164, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 164, 17)) +>b : Symbol(b, Decl(iteratorZip.ts, 164, 28)) +>paddingO : Symbol(paddingO, Decl(iteratorZip.ts, 163, 5)) + +const paddingQ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); +>paddingQ : Symbol(paddingQ, Decl(iteratorZip.ts, 166, 5)) +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZip.ts, 166, 45)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 166, 62)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const paddingR: [number | undefined, string | undefined][] = paddingQ; +>paddingR : Symbol(paddingR, Decl(iteratorZip.ts, 167, 5)) +>paddingQ : Symbol(paddingQ, Decl(iteratorZip.ts, 166, 5)) + +const paddingS: [number, string][] = paddingQ; +>paddingS : Symbol(paddingS, Decl(iteratorZip.ts, 168, 5)) +>paddingQ : Symbol(paddingQ, Decl(iteratorZip.ts, 166, 5)) + +const paddingT = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); +>paddingT : Symbol(paddingT, Decl(iteratorZip.ts, 169, 5)) +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 169, 36)) +>b : Symbol(b, Decl(iteratorZip.ts, 169, 44)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 169, 58)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 169, 75)) +>a : Symbol(a, Decl(iteratorZip.ts, 169, 86)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const paddingU: { a: number | undefined; b: string | undefined; }[] = paddingT; +>paddingU : Symbol(paddingU, Decl(iteratorZip.ts, 170, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 170, 17)) +>b : Symbol(b, Decl(iteratorZip.ts, 170, 40)) +>paddingT : Symbol(paddingT, Decl(iteratorZip.ts, 169, 5)) + +const paddingV: { a: number; b: string; }[] = paddingT; +>paddingV : Symbol(paddingV, Decl(iteratorZip.ts, 171, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 171, 17)) +>b : Symbol(b, Decl(iteratorZip.ts, 171, 28)) +>paddingT : Symbol(paddingT, Decl(iteratorZip.ts, 169, 5)) + +declare const paddingW: readonly [number, string]; +>paddingW : Symbol(paddingW, Decl(iteratorZip.ts, 173, 13)) + +const paddingX: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingW }).toArray(); +>paddingX : Symbol(paddingX, Decl(iteratorZip.ts, 174, 5)) +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingW }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZip.ts, 174, 65)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 174, 82)) +>paddingW : Symbol(paddingW, Decl(iteratorZip.ts, 173, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const paddingY: [number, string?]; +>paddingY : Symbol(paddingY, Decl(iteratorZip.ts, 175, 13)) + +const paddingZ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY }).toArray(); +>paddingZ : Symbol(paddingZ, Decl(iteratorZip.ts, 176, 5)) +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZip.ts, 176, 45)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 176, 62)) +>paddingY : Symbol(paddingY, Decl(iteratorZip.ts, 175, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const paddingA1: [number, string][] = paddingZ; +>paddingA1 : Symbol(paddingA1, Decl(iteratorZip.ts, 177, 5)) +>paddingZ : Symbol(paddingZ, Decl(iteratorZip.ts, 176, 5)) + +declare const paddingB1: [Iterable] | [Iterable, Iterable]; +>paddingB1 : Symbol(paddingB1, Decl(iteratorZip.ts, 179, 13)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + +const paddingC1 = Iterator.zip(paddingB1, { mode: "longest", padding: [0] }).toArray(); +>paddingC1 : Symbol(paddingC1, Decl(iteratorZip.ts, 180, 5)) +>Iterator.zip(paddingB1, { mode: "longest", padding: [0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>paddingB1 : Symbol(paddingB1, Decl(iteratorZip.ts, 179, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 180, 43)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 180, 60)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const paddingD1: number[][] = paddingC1; +>paddingD1 : Symbol(paddingD1, Decl(iteratorZip.ts, 181, 5)) +>paddingC1 : Symbol(paddingC1, Decl(iteratorZip.ts, 180, 5)) + +declare const paddingE1: { a: Iterable; } | { b: Iterable; }; +>paddingE1 : Symbol(paddingE1, Decl(iteratorZip.ts, 182, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 182, 26)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>b : Symbol(b, Decl(iteratorZip.ts, 182, 53)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + +const paddingF1 = Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: 0 } }).toArray(); +>paddingF1 : Symbol(paddingF1, Decl(iteratorZip.ts, 183, 5)) +>Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>paddingE1 : Symbol(paddingE1, Decl(iteratorZip.ts, 182, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 183, 48)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 183, 65)) +>a : Symbol(a, Decl(iteratorZip.ts, 183, 76)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const paddingG1: ({ a: number; } | { b: string; })[] = paddingF1; +>paddingG1 : Symbol(paddingG1, Decl(iteratorZip.ts, 184, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 184, 19)) +>b : Symbol(b, Decl(iteratorZip.ts, 184, 36)) +>paddingF1 : Symbol(paddingF1, Decl(iteratorZip.ts, 183, 5)) + +declare const paddingH1: { a: number; } | { b: string; }; +>paddingH1 : Symbol(paddingH1, Decl(iteratorZip.ts, 186, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 186, 26)) +>b : Symbol(b, Decl(iteratorZip.ts, 186, 43)) + +const paddingI1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: paddingH1 }).toArray(); +>paddingI1 : Symbol(paddingI1, Decl(iteratorZip.ts, 187, 5)) +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: paddingH1 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 187, 37)) +>b : Symbol(b, Decl(iteratorZip.ts, 187, 45)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 187, 59)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 187, 76)) +>paddingH1 : Symbol(paddingH1, Decl(iteratorZip.ts, 186, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const paddingJ1: { a: number; b: string; }[] = paddingI1; +>paddingJ1 : Symbol(paddingJ1, Decl(iteratorZip.ts, 188, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 188, 18)) +>b : Symbol(b, Decl(iteratorZip.ts, 188, 29)) +>paddingI1 : Symbol(paddingI1, Decl(iteratorZip.ts, 187, 5)) + +const paddingK1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); +>paddingK1 : Symbol(paddingK1, Decl(iteratorZip.ts, 190, 5)) +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 190, 37)) +>b : Symbol(b, Decl(iteratorZip.ts, 190, 45)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 190, 57)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 190, 74)) +>a : Symbol(a, Decl(iteratorZip.ts, 190, 85)) +>undefined : Symbol(undefined) +>b : Symbol(b, Decl(iteratorZip.ts, 190, 99)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const paddingL1: { a: number; b: number; }[] = paddingK1; +>paddingL1 : Symbol(paddingL1, Decl(iteratorZip.ts, 191, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 191, 18)) +>b : Symbol(b, Decl(iteratorZip.ts, 191, 29)) +>paddingK1 : Symbol(paddingK1, Decl(iteratorZip.ts, 190, 5)) + +declare const paddingM1: { [K in `a${string}`]: Iterable; }; +>paddingM1 : Symbol(paddingM1, Decl(iteratorZip.ts, 193, 13)) +>K : Symbol(K, Decl(iteratorZip.ts, 193, 28)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) + +const paddingN1 = Iterator.zipKeyed(paddingM1, { mode: "longest", padding: {} }).toArray(); +>paddingN1 : Symbol(paddingN1, Decl(iteratorZip.ts, 194, 5)) +>Iterator.zipKeyed(paddingM1, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>paddingM1 : Symbol(paddingM1, Decl(iteratorZip.ts, 193, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 194, 48)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 194, 65)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const paddingO1: { [K in `a${string}`]: number; }[] = paddingN1; +>paddingO1 : Symbol(paddingO1, Decl(iteratorZip.ts, 195, 5)) +>K : Symbol(K, Decl(iteratorZip.ts, 195, 20)) +>paddingN1 : Symbol(paddingN1, Decl(iteratorZip.ts, 194, 5)) + +declare const paddingP1: unique symbol; +>paddingP1 : Symbol(paddingP1, Decl(iteratorZip.ts, 197, 13)) + +const paddingQ1: { [paddingP1]: number; }[] = Iterator.zipKeyed({ [paddingP1]: [1] }, { mode: "longest", padding: { [paddingP1]: 0 } }).toArray(); +>paddingQ1 : Symbol(paddingQ1, Decl(iteratorZip.ts, 198, 5)) +>[paddingP1] : Symbol([paddingP1], Decl(iteratorZip.ts, 198, 18)) +>paddingP1 : Symbol(paddingP1, Decl(iteratorZip.ts, 197, 13)) +>Iterator.zipKeyed({ [paddingP1]: [1] }, { mode: "longest", padding: { [paddingP1]: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>[paddingP1] : Symbol([paddingP1], Decl(iteratorZip.ts, 198, 65)) +>paddingP1 : Symbol(paddingP1, Decl(iteratorZip.ts, 197, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 198, 87)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 198, 104)) +>[paddingP1] : Symbol([paddingP1], Decl(iteratorZip.ts, 198, 115)) +>paddingP1 : Symbol(paddingP1, Decl(iteratorZip.ts, 197, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const paddingR1: Record & { a: number; }; +>paddingR1 : Symbol(paddingR1, Decl(iteratorZip.ts, 200, 13)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 200, 51)) + +const paddingS1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: paddingR1 }).toArray(); +>paddingS1 : Symbol(paddingS1, Decl(iteratorZip.ts, 201, 5)) +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: paddingR1 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 201, 37)) +>b : Symbol(b, Decl(iteratorZip.ts, 201, 45)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 201, 57)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 201, 74)) +>paddingR1 : Symbol(paddingR1, Decl(iteratorZip.ts, 200, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const paddingT1: { a: number; b: number | undefined; }[] = paddingS1; +>paddingT1 : Symbol(paddingT1, Decl(iteratorZip.ts, 202, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 202, 18)) +>b : Symbol(b, Decl(iteratorZip.ts, 202, 29)) +>paddingS1 : Symbol(paddingS1, Decl(iteratorZip.ts, 201, 5)) + +const paddingU1: { a: number; b: number; }[] = paddingS1; +>paddingU1 : Symbol(paddingU1, Decl(iteratorZip.ts, 203, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 203, 18)) +>b : Symbol(b, Decl(iteratorZip.ts, 203, 29)) +>paddingS1 : Symbol(paddingS1, Decl(iteratorZip.ts, 201, 5)) + +declare const paddingV1: [number] | [number, string]; +>paddingV1 : Symbol(paddingV1, Decl(iteratorZip.ts, 205, 13)) + +const paddingW1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingV1 }).toArray(); +>paddingW1 : Symbol(paddingW1, Decl(iteratorZip.ts, 206, 5)) +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingV1 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZip.ts, 206, 46)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 206, 63)) +>paddingV1 : Symbol(paddingV1, Decl(iteratorZip.ts, 205, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const paddingX1: [number, string | undefined][] = paddingW1; +>paddingX1 : Symbol(paddingX1, Decl(iteratorZip.ts, 207, 5)) +>paddingW1 : Symbol(paddingW1, Decl(iteratorZip.ts, 206, 5)) + +const paddingY1: [number, string][] = paddingW1; +>paddingY1 : Symbol(paddingY1, Decl(iteratorZip.ts, 208, 5)) +>paddingW1 : Symbol(paddingW1, Decl(iteratorZip.ts, 206, 5)) + +const paddingZ1: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); +>paddingZ1 : Symbol(paddingZ1, Decl(iteratorZip.ts, 210, 5)) +>Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(iteratorZip.ts, 210, 76)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 210, 93)) +>undefined : Symbol(undefined) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const paddingA2: { a: number | undefined; b: number; }[] = paddingK1; +>paddingA2 : Symbol(paddingA2, Decl(iteratorZip.ts, 211, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 211, 18)) +>b : Symbol(b, Decl(iteratorZip.ts, 211, 41)) +>paddingK1 : Symbol(paddingK1, Decl(iteratorZip.ts, 190, 5)) + +// Own properties + +class InputsWithPrototypeMembers { +>InputsWithPrototypeMembers : Symbol(InputsWithPrototypeMembers, Decl(iteratorZip.ts, 211, 69)) + + values = [1, 2]; +>values : Symbol(InputsWithPrototypeMembers.values, Decl(iteratorZip.ts, 215, 34)) + + get label() { +>label : Symbol(InputsWithPrototypeMembers.label, Decl(iteratorZip.ts, 216, 20)) + + return "inputs"; + } + + describe() { +>describe : Symbol(InputsWithPrototypeMembers.describe, Decl(iteratorZip.ts, 220, 5)) + + return this.label; +>this.label : Symbol(InputsWithPrototypeMembers.label, Decl(iteratorZip.ts, 216, 20)) +>this : Symbol(InputsWithPrototypeMembers, Decl(iteratorZip.ts, 211, 69)) +>label : Symbol(InputsWithPrototypeMembers.label, Decl(iteratorZip.ts, 216, 20)) + } +} + +const instance = new InputsWithPrototypeMembers(); +>instance : Symbol(instance, Decl(iteratorZip.ts, 227, 5)) +>InputsWithPrototypeMembers : Symbol(InputsWithPrototypeMembers, Decl(iteratorZip.ts, 211, 69)) + +const inherited = Iterator.zipKeyed(instance).toArray(); +>inherited : Symbol(inherited, Decl(iteratorZip.ts, 228, 5)) +>Iterator.zipKeyed(instance).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>instance : Symbol(instance, Decl(iteratorZip.ts, 227, 5)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const inheritedStrict = Iterator.zipKeyed(instance, { mode: "strict" }).toArray(); +>inheritedStrict : Symbol(inheritedStrict, Decl(iteratorZip.ts, 229, 5)) +>Iterator.zipKeyed(instance, { mode: "strict" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>instance : Symbol(instance, Decl(iteratorZip.ts, 227, 5)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 229, 53)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const inheritedLongest = Iterator.zipKeyed(instance, { mode: "longest" }).toArray(); +>inheritedLongest : Symbol(inheritedLongest, Decl(iteratorZip.ts, 230, 5)) +>Iterator.zipKeyed(instance, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>instance : Symbol(instance, Decl(iteratorZip.ts, 227, 5)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 230, 54)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const inheritedPadded = Iterator.zipKeyed(instance, { mode: "longest", padding: { values: 0 } }).toArray(); +>inheritedPadded : Symbol(inheritedPadded, Decl(iteratorZip.ts, 231, 5)) +>Iterator.zipKeyed(instance, { mode: "longest", padding: { values: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>instance : Symbol(instance, Decl(iteratorZip.ts, 227, 5)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 231, 53)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 231, 70)) +>values : Symbol(values, Decl(iteratorZip.ts, 231, 81)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const hiddenInputs = { values: [1, 2], label: "inputs" }; +>hiddenInputs : Symbol(hiddenInputs, Decl(iteratorZip.ts, 233, 5)) +>values : Symbol(values, Decl(iteratorZip.ts, 233, 22)) +>label : Symbol(label, Decl(iteratorZip.ts, 233, 38)) + +Object.defineProperty(hiddenInputs, "label", { enumerable: false }); +>Object.defineProperty : Symbol(ObjectConstructor.defineProperty, Decl(lib.es5.d.ts, --, --)) +>Object : Symbol(Object, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>defineProperty : Symbol(ObjectConstructor.defineProperty, Decl(lib.es5.d.ts, --, --)) +>hiddenInputs : Symbol(hiddenInputs, Decl(iteratorZip.ts, 233, 5)) +>enumerable : Symbol(enumerable, Decl(iteratorZip.ts, 234, 46)) + +const nonEnumerable = Iterator.zipKeyed(hiddenInputs).toArray(); +>nonEnumerable : Symbol(nonEnumerable, Decl(iteratorZip.ts, 235, 5)) +>Iterator.zipKeyed(hiddenInputs).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>hiddenInputs : Symbol(hiddenInputs, Decl(iteratorZip.ts, 233, 5)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const nonEnumerablePadded = Iterator.zipKeyed(hiddenInputs, { mode: "longest", padding: { values: 0 } }).toArray(); +>nonEnumerablePadded : Symbol(nonEnumerablePadded, Decl(iteratorZip.ts, 236, 5)) +>Iterator.zipKeyed(hiddenInputs, { mode: "longest", padding: { values: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>hiddenInputs : Symbol(hiddenInputs, Decl(iteratorZip.ts, 233, 5)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 236, 61)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 236, 78)) +>values : Symbol(values, Decl(iteratorZip.ts, 236, 89)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +// The same static shape can have an enumerable non-iterator property instead. +// Such inputs are accepted by the fallback and checked at runtime. +const enumerableInputs = { values: [1, 2], label: "inputs" }; +>enumerableInputs : Symbol(enumerableInputs, Decl(iteratorZip.ts, 240, 5)) +>values : Symbol(values, Decl(iteratorZip.ts, 240, 26)) +>label : Symbol(label, Decl(iteratorZip.ts, 240, 42)) + +const enumerable = Iterator.zipKeyed(enumerableInputs).toArray(); +>enumerable : Symbol(enumerable, Decl(iteratorZip.ts, 241, 5)) +>Iterator.zipKeyed(enumerableInputs).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>enumerableInputs : Symbol(enumerableInputs, Decl(iteratorZip.ts, 240, 5)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +// The array's length and methods are not enumerable own properties. +const arrayInputs = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); +>arrayInputs : Symbol(arrayInputs, Decl(iteratorZip.ts, 244, 5)) +>Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +// The fallback must not claim that ignored properties exist on yielded objects. +const inheritedLabel: string = inherited[0].label; +>inheritedLabel : Symbol(inheritedLabel, Decl(iteratorZip.ts, 247, 5)) +>inherited : Symbol(inherited, Decl(iteratorZip.ts, 228, 5)) + +const nonEnumerableLabel: string = nonEnumerable[0].label; +>nonEnumerableLabel : Symbol(nonEnumerableLabel, Decl(iteratorZip.ts, 248, 5)) +>nonEnumerable : Symbol(nonEnumerable, Decl(iteratorZip.ts, 235, 5)) + +// Precise record inference still handles symbol keys and padding. +declare const ownKey: unique symbol; +>ownKey : Symbol(ownKey, Decl(iteratorZip.ts, 251, 13)) + +const precise: { values: number; [ownKey]: string; }[] = Iterator.zipKeyed({ values: [1], [ownKey]: ["a"] }).toArray(); +>precise : Symbol(precise, Decl(iteratorZip.ts, 252, 5)) +>values : Symbol(values, Decl(iteratorZip.ts, 252, 16)) +>[ownKey] : Symbol([ownKey], Decl(iteratorZip.ts, 252, 32)) +>ownKey : Symbol(ownKey, Decl(iteratorZip.ts, 251, 13)) +>Iterator.zipKeyed({ values: [1], [ownKey]: ["a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>values : Symbol(values, Decl(iteratorZip.ts, 252, 76)) +>[ownKey] : Symbol([ownKey], Decl(iteratorZip.ts, 252, 89)) +>ownKey : Symbol(ownKey, Decl(iteratorZip.ts, 251, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const preciseLongest: { values: number | undefined; }[] = Iterator.zipKeyed({ values: [1] }, { mode: "longest" }).toArray(); +>preciseLongest : Symbol(preciseLongest, Decl(iteratorZip.ts, 253, 5)) +>values : Symbol(values, Decl(iteratorZip.ts, 253, 23)) +>Iterator.zipKeyed({ values: [1] }, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>values : Symbol(values, Decl(iteratorZip.ts, 253, 77)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 253, 94)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const precisePadded: { values: number; }[] = Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: 0 } }).toArray(); +>precisePadded : Symbol(precisePadded, Decl(iteratorZip.ts, 254, 5)) +>values : Symbol(values, Decl(iteratorZip.ts, 254, 22)) +>Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>values : Symbol(values, Decl(iteratorZip.ts, 254, 64)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 254, 81)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 254, 98)) +>values : Symbol(values, Decl(iteratorZip.ts, 254, 109)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const emptyOwnProperties: never[] = Iterator.zipKeyed({}).toArray(); +>emptyOwnProperties : Symbol(emptyOwnProperties, Decl(iteratorZip.ts, 255, 5)) +>Iterator.zipKeyed({}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +Iterator.zipKeyed(0); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) + +Iterator.zipKeyed(null); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) + +Iterator.zipKeyed(instance, { mode: "invalid" }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>instance : Symbol(instance, Decl(iteratorZip.ts, 227, 5)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 259, 29)) + +Iterator.zipKeyed(instance, { mode: "shortest", padding: {} }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>instance : Symbol(instance, Decl(iteratorZip.ts, 227, 5)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 260, 29)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 260, 47)) + +Iterator.zipKeyed(instance, { mode: "longest", padding: 0 }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>instance : Symbol(instance, Decl(iteratorZip.ts, 227, 5)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 261, 29)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 261, 46)) + +Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: "invalid" } }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>values : Symbol(values, Decl(iteratorZip.ts, 262, 19)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 262, 36)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 262, 53)) +>values : Symbol(values, Decl(iteratorZip.ts, 262, 64)) + diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).types b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).types new file mode 100644 index 0000000000000..dc0aee2aaaaac --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).types @@ -0,0 +1,1939 @@ +//// [tests/cases/compiler/iteratorZip.ts] //// + +=== iteratorZip.ts === +declare const key: unique symbol; +>key : unique symbol + +const tuples: [number, string][] = Iterator.zip([ +>tuples : [number, string][] +>Iterator.zip([ [1, 2], new Set(["a", "b"]),] as const).toArray() : [1 | 2, string][] +>Iterator.zip([ [1, 2], new Set(["a", "b"]),] as const).toArray : () => [1 | 2, string][] +>Iterator.zip([ [1, 2], new Set(["a", "b"]),] as const) : IteratorObject<[1 | 2, string], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[ [1, 2], new Set(["a", "b"]),] as const : [readonly [1, 2], Set] +>[ [1, 2], new Set(["a", "b"]),] : [readonly [1, 2], Set] + + [1, 2], +>[1, 2] : readonly [1, 2] +>1 : 1 +>2 : 2 + + new Set(["a", "b"]), +>new Set(["a", "b"]) : Set +>Set : SetConstructor +>["a", "b"] : string[] +>"a" : "a" +>"b" : "b" + +] as const).toArray(); +>toArray : () => [1 | 2, string][] + +tuples[0][0] = 2; +>tuples[0][0] = 2 : 2 +>tuples[0][0] : number +>tuples[0] : [number, string] +>tuples : [number, string][] +>0 : 0 +>0 : 0 +>2 : 2 + +const shortestTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray(); +>shortestTuples : [number, string][] +>Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray() : [1, "a"][] +>Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray : () => [1, "a"][] +>Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }) : IteratorObject<[1, "a"], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] as const : [readonly [1], readonly ["a"]] +>[[1], ["a"]] : [readonly [1], readonly ["a"]] +>[1] : readonly [1] +>1 : 1 +>["a"] : readonly ["a"] +>"a" : "a" +>{ mode: "shortest" } : { mode: "shortest"; } +>mode : "shortest" +>"shortest" : "shortest" +>toArray : () => [1, "a"][] + +const strictTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray(); +>strictTuples : [number, string][] +>Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray() : [1, "a"][] +>Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray : () => [1, "a"][] +>Iterator.zip([[1], ["a"]] as const, { mode: "strict" }) : IteratorObject<[1, "a"], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] as const : [readonly [1], readonly ["a"]] +>[[1], ["a"]] : [readonly [1], readonly ["a"]] +>[1] : readonly [1] +>1 : 1 +>["a"] : readonly ["a"] +>"a" : "a" +>{ mode: "strict" } : { mode: "strict"; } +>mode : "strict" +>"strict" : "strict" +>toArray : () => [1, "a"][] + +const longestTuplesWithPadding: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray(); +>longestTuplesWithPadding : [number, string][] +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray() : [number, string][] +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray : () => [number, string][] +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }) : IteratorObject<[number, string], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] as const : [readonly [1], readonly ["a"]] +>[[1], ["a"]] : [readonly [1], readonly ["a"]] +>[1] : readonly [1] +>1 : 1 +>["a"] : readonly ["a"] +>"a" : "a" +>{ mode: "longest", padding: [1, "a"] } : { mode: "longest"; padding: [1, "a"]; } +>mode : "longest" +>"longest" : "longest" +>padding : [1, "a"] +>[1, "a"] : [1, "a"] +>1 : 1 +>"a" : "a" +>toArray : () => [number, string][] + +const longestTuplesWithoutPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray(); +>longestTuplesWithoutPadding : [number | undefined, string | undefined][] +>Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray() : [1 | undefined, "a" | undefined][] +>Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray : () => [1 | undefined, "a" | undefined][] +>Iterator.zip([[1], ["a"]] as const, { mode: "longest" }) : IteratorObject<[1 | undefined, "a" | undefined], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] as const : [readonly [1], readonly ["a"]] +>[[1], ["a"]] : [readonly [1], readonly ["a"]] +>[1] : readonly [1] +>1 : 1 +>["a"] : readonly ["a"] +>"a" : "a" +>{ mode: "longest" } : { mode: "longest"; } +>mode : "longest" +>"longest" : "longest" +>toArray : () => [1 | undefined, "a" | undefined][] + +const longestTuplesWithPartialPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray(); +>longestTuplesWithPartialPadding : [number | undefined, string | undefined][] +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray() : [number, "a" | undefined][] +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray : () => [number, "a" | undefined][] +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }) : IteratorObject<[number, "a" | undefined], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] as const : [readonly [1], readonly ["a"]] +>[[1], ["a"]] : [readonly [1], readonly ["a"]] +>[1] : readonly [1] +>1 : 1 +>["a"] : readonly ["a"] +>"a" : "a" +>{ mode: "longest", padding: [1] } : { mode: "longest"; padding: [1]; } +>mode : "longest" +>"longest" : "longest" +>padding : [1] +>[1] : [1] +>1 : 1 +>toArray : () => [number, "a" | undefined][] + +declare const maybeLongestOptions: { mode: "shortest"; } | { mode: "longest"; }; +>maybeLongestOptions : { mode: "shortest"; } | { mode: "longest"; } +>mode : "shortest" +>mode : "longest" + +const maybeLongestTuples: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray(); +>maybeLongestTuples : [number | undefined, string | undefined][] +>Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray() : [1 | undefined, "a" | undefined][] +>Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray : () => [1 | undefined, "a" | undefined][] +>Iterator.zip([[1], ["a"]] as const, maybeLongestOptions) : IteratorObject<[1 | undefined, "a" | undefined], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] as const : [readonly [1], readonly ["a"]] +>[[1], ["a"]] : [readonly [1], readonly ["a"]] +>[1] : readonly [1] +>1 : 1 +>["a"] : readonly ["a"] +>"a" : "a" +>maybeLongestOptions : { mode: "shortest"; } | { mode: "longest"; } +>toArray : () => [1 | undefined, "a" | undefined][] + +const empty: never[] = Iterator.zip([]).toArray(); +>empty : never[] +>Iterator.zip([]).toArray() : never[] +>Iterator.zip([]).toArray : () => never[] +>Iterator.zip([]) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[] : [] +>toArray : () => never[] + +const emptyLongest: never[] = Iterator.zip([], { mode: "longest" }).toArray(); +>emptyLongest : never[] +>Iterator.zip([], { mode: "longest" }).toArray() : never[] +>Iterator.zip([], { mode: "longest" }).toArray : () => never[] +>Iterator.zip([], { mode: "longest" }) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[] : [] +>{ mode: "longest" } : { mode: "longest"; } +>mode : "longest" +>"longest" : "longest" +>toArray : () => never[] + +declare const iterables: Iterable>; +>iterables : Iterable> + +const arrays: number[][] = Iterator.zip(iterables).toArray(); +>arrays : number[][] +>Iterator.zip(iterables).toArray() : number[][] +>Iterator.zip(iterables).toArray : () => number[][] +>Iterator.zip(iterables) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>iterables : Iterable> +>toArray : () => number[][] + +const longestArrays: (number | undefined)[][] = Iterator.zip(iterables, { mode: "longest" }).toArray(); +>longestArrays : (number | undefined)[][] +>Iterator.zip(iterables, { mode: "longest" }).toArray() : (number | undefined)[][] +>Iterator.zip(iterables, { mode: "longest" }).toArray : () => (number | undefined)[][] +>Iterator.zip(iterables, { mode: "longest" }) : IteratorObject<(number | undefined)[], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>iterables : Iterable> +>{ mode: "longest" } : { mode: "longest"; } +>mode : "longest" +>"longest" : "longest" +>toArray : () => (number | undefined)[][] + +const maybeLongestArrays: (number | undefined)[][] = Iterator.zip(iterables, maybeLongestOptions).toArray(); +>maybeLongestArrays : (number | undefined)[][] +>Iterator.zip(iterables, maybeLongestOptions).toArray() : (number | undefined)[][] +>Iterator.zip(iterables, maybeLongestOptions).toArray : () => (number | undefined)[][] +>Iterator.zip(iterables, maybeLongestOptions) : IteratorObject<(number | undefined)[], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>iterables : Iterable> +>maybeLongestOptions : { mode: "shortest"; } | { mode: "longest"; } +>toArray : () => (number | undefined)[][] + +declare const iterableArray: Iterable[]; +>iterableArray : Iterable[] + +const longestArrayWithPadding: (number | undefined)[][] = Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray(); +>longestArrayWithPadding : (number | undefined)[][] +>Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray() : (number | undefined)[][] +>Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray : () => (number | undefined)[][] +>Iterator.zip(iterableArray, { mode: "longest", padding: [] }) : IteratorObject<(number | undefined)[], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>iterableArray : Iterable[] +>{ mode: "longest", padding: [] } : { mode: "longest"; padding: []; } +>mode : "longest" +>"longest" : "longest" +>padding : [] +>[] : [] +>toArray : () => (number | undefined)[][] + +const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ +>objects : { a: number; b: string; [key]: boolean; }[] +>a : number +>b : string +>[key] : boolean +>key : unique symbol +>Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const).toArray() : { a: 1 | 2; b: string; [key]: boolean; }[] +>Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const).toArray : () => { a: 1 | 2; b: string; [key]: boolean; }[] +>Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const) : IteratorObject<{ a: 1 | 2; b: string; [key]: boolean; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const : { readonly a: readonly [1, 2]; readonly b: Set; readonly [key]: readonly [true, false]; } +>{ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} : { readonly a: readonly [1, 2]; readonly b: Set; readonly [key]: readonly [true, false]; } + + a: [1, 2], +>a : readonly [1, 2] +>[1, 2] : readonly [1, 2] +>1 : 1 +>2 : 2 + + b: new Set(["a", "b"]), +>b : Set +>new Set(["a", "b"]) : Set +>Set : SetConstructor +>["a", "b"] : string[] +>"a" : "a" +>"b" : "b" + + [key]: [true, false], +>[key] : readonly [true, false] +>key : unique symbol +>[true, false] : readonly [true, false] +>true : true +>false : false + +} as const).toArray(); +>toArray : () => { a: 1 | 2; b: string; [key]: boolean; }[] + +objects[0].a = 2; +>objects[0].a = 2 : 2 +>objects[0].a : number +>objects[0] : { a: number; b: string; [key]: boolean; } +>objects : { a: number; b: string; [key]: boolean; }[] +>0 : 0 +>a : number +>2 : 2 + +const longestObjectsWithPadding: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +>longestObjectsWithPadding : { a: number; b: string; }[] +>a : number +>b : string +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}).toArray() : { a: number; b: string; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}).toArray : () => { a: number; b: string; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}) : IteratorObject<{ a: number; b: string; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } +>{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } +>a : readonly [1] +>[1] : readonly [1] +>1 : 1 +>b : readonly ["a"] +>["a"] : readonly ["a"] +>"a" : "a" +>{ mode: "longest", padding: { a: 1, b: "a" },} : { mode: "longest"; padding: { a: 1; b: "a"; }; } + + mode: "longest", +>mode : "longest" +>"longest" : "longest" + + padding: { a: 1, b: "a" }, +>padding : { a: 1; b: "a"; } +>{ a: 1, b: "a" } : { a: 1; b: "a"; } +>a : 1 +>1 : 1 +>b : "a" +>"a" : "a" + +}).toArray(); +>toArray : () => { a: number; b: string; }[] + +const longestObjectsWithoutPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +>longestObjectsWithoutPadding : { a: number | undefined; b: string | undefined; }[] +>a : number | undefined +>b : string | undefined +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}).toArray() : { a: 1 | undefined; b: "a" | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}).toArray : () => { a: 1 | undefined; b: "a" | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}) : IteratorObject<{ a: 1 | undefined; b: "a" | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } +>{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } +>a : readonly [1] +>[1] : readonly [1] +>1 : 1 +>b : readonly ["a"] +>["a"] : readonly ["a"] +>"a" : "a" +>{ mode: "longest",} : { mode: "longest"; } + + mode: "longest", +>mode : "longest" +>"longest" : "longest" + +}).toArray(); +>toArray : () => { a: 1 | undefined; b: "a" | undefined; }[] + +const longestObjectsWithPartialPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +>longestObjectsWithPartialPadding : { a: number | undefined; b: string | undefined; }[] +>a : number | undefined +>b : string | undefined +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}).toArray() : { a: 1 | undefined; b: string; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}).toArray : () => { a: 1 | undefined; b: string; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}) : IteratorObject<{ a: 1 | undefined; b: string; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } +>{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } +>a : readonly [1] +>[1] : readonly [1] +>1 : 1 +>b : readonly ["a"] +>["a"] : readonly ["a"] +>"a" : "a" +>{ mode: "longest", padding: { b: "a" },} : { mode: "longest"; padding: { b: "a"; }; } + + mode: "longest", +>mode : "longest" +>"longest" : "longest" + + padding: { b: "a" }, +>padding : { b: "a"; } +>{ b: "a" } : { b: "a"; } +>b : "a" +>"a" : "a" + +}).toArray(); +>toArray : () => { a: 1 | undefined; b: string; }[] + +const maybeLongestObjects: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray(); +>maybeLongestObjects : { a: number | undefined; b: string | undefined; }[] +>a : number | undefined +>b : string | undefined +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray() : { a: 1 | undefined; b: "a" | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray : () => { a: 1 | undefined; b: "a" | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions) : IteratorObject<{ a: 1 | undefined; b: "a" | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } +>{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } +>a : readonly [1] +>[1] : readonly [1] +>1 : 1 +>b : readonly ["a"] +>["a"] : readonly ["a"] +>"a" : "a" +>maybeLongestOptions : { mode: "shortest"; } | { mode: "longest"; } +>toArray : () => { a: 1 | undefined; b: "a" | undefined; }[] + +interface Inputs { + a: Iterable; +>a : Iterable + + b: Iterator; +>b : Iterator +} + +declare const inputs: Inputs; +>inputs : Inputs + +const rows: { a: number; b: string; }[] = Iterator.zipKeyed(inputs).toArray(); +>rows : { a: number; b: string; }[] +>a : number +>b : string +>Iterator.zipKeyed(inputs).toArray() : { a: number; b: string; }[] +>Iterator.zipKeyed(inputs).toArray : () => { a: number; b: string; }[] +>Iterator.zipKeyed(inputs) : IteratorObject<{ a: number; b: string; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>inputs : Inputs +>toArray : () => { a: number; b: string; }[] + +Iterator.zip([[1]], { mode: "invalid" }); +>Iterator.zip([[1]], { mode: "invalid" }) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1]] : [number[]] +>[1] : number[] +>1 : 1 +>{ mode: "invalid" } : { mode: "invalid"; } +>mode : "invalid" +>"invalid" : "invalid" + +Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }); +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] as const : readonly [readonly [1], readonly ["a"]] +>[[1], ["a"]] : readonly [readonly [1], readonly ["a"]] +>[1] : readonly [1] +>1 : 1 +>["a"] : readonly ["a"] +>"a" : "a" +>{ mode: "longest", padding: [true] } : { mode: "longest"; padding: boolean[]; } +>mode : "longest" +>"longest" : "longest" +>padding : boolean[] +>[true] : boolean[] +>true : true + +Iterator.zip([[1]], { mode: "shortest", padding: [1] }); +>Iterator.zip([[1]], { mode: "shortest", padding: [1] }) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1]] : [number[]] +>[1] : number[] +>1 : 1 +>{ mode: "shortest", padding: [1] } : { mode: "shortest"; padding: number[]; } +>mode : "shortest" +>"shortest" : "shortest" +>padding : number[] +>[1] : number[] +>1 : 1 + +Iterator.zip(0); +>Iterator.zip(0) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>0 : 0 + +Iterator.zipKeyed({ a: 0 }); +>Iterator.zipKeyed({ a: 0 }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: 0 } : { a: number; } +>a : number +>0 : 0 + +const emptyKeyed: never[] = Iterator.zipKeyed({}).toArray(); +>emptyKeyed : never[] +>Iterator.zipKeyed({}).toArray() : never[] +>Iterator.zipKeyed({}).toArray : () => never[] +>Iterator.zipKeyed({}) : IteratorObject +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{} : {} +>toArray : () => never[] + +const emptyKeyedLongest: never[] = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); +>emptyKeyedLongest : never[] +>Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray() : never[] +>Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray : () => never[] +>Iterator.zipKeyed({}, { mode: "longest", padding: {} }) : IteratorObject +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{} : {} +>{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } +>mode : "longest" +>"longest" : "longest" +>padding : {} +>{} : {} +>toArray : () => never[] + +declare const unionInputs: { a: Iterable; } | { b: Iterator; }; +>unionInputs : { a: Iterable; } | { b: Iterator; } +>a : Iterable +>b : Iterator + +const unionRows: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(unionInputs).toArray(); +>unionRows : ({ a: number; } | { b: string; })[] +>a : number +>b : string +>Iterator.zipKeyed(unionInputs).toArray() : ({ a: number; } | { b: string; })[] +>Iterator.zipKeyed(unionInputs).toArray : () => ({ a: number; } | { b: string; })[] +>Iterator.zipKeyed(unionInputs) : IteratorObject<{ a: number; } | { b: string; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>unionInputs : { a: Iterable; } | { b: Iterator; } +>toArray : () => ({ a: number; } | { b: string; })[] + +// Inputs + +Iterator.zip("ab"); +>Iterator.zip("ab") : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>"ab" : "ab" + +Iterator.zip(["ab"]); +>Iterator.zip(["ab"]) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>["ab"] : [string] +>"ab" : "ab" + +Iterator.zip(new Set(["ab"])); +>Iterator.zip(new Set(["ab"])) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>new Set(["ab"]) : Set +>Set : SetConstructor +>["ab"] : string[] +>"ab" : "ab" + +Iterator.zipKeyed("ab"); +>Iterator.zipKeyed("ab") : IteratorObject +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>"ab" : "ab" + +Iterator.zipKeyed({ a: "ab" }); +>Iterator.zipKeyed({ a: "ab" }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: "ab" } : { a: string; } +>a : string +>"ab" : "ab" + +Iterator.zip([], { mode: "longest", padding: "ab" }); +>Iterator.zip([], { mode: "longest", padding: "ab" }) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[] : [] +>{ mode: "longest", padding: "ab" } : { mode: "longest"; padding: string; } +>mode : "longest" +>"longest" : "longest" +>padding : string +>"ab" : "ab" + +Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); +>Iterator.zip([["a"]], { mode: "longest", padding: "ab" }) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[["a"]] : [string[]] +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: "ab" } : { mode: "longest"; padding: string; } +>mode : "longest" +>"longest" : "longest" +>padding : string +>"ab" : "ab" + +Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); +>Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }) : IteratorObject +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{} : {} +>{ mode: "longest", padding: "ab" } : { mode: "longest"; padding: string; } +>mode : "longest" +>"longest" : "longest" +>padding : string +>"ab" : "ab" + +const a: [string][] = Iterator.zip([new String("ab")]).toArray(); +>a : [string][] +>Iterator.zip([new String("ab")]).toArray() : [string][] +>Iterator.zip([new String("ab")]).toArray : () => [string][] +>Iterator.zip([new String("ab")]) : IteratorObject<[string], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[new String("ab")] : [String] +>new String("ab") : String +>String : StringConstructor +>"ab" : "ab" +>toArray : () => [string][] + +const b: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); +>b : { a: string; }[] +>a : string +>Iterator.zipKeyed({ a: new String("ab") }).toArray() : { a: string; }[] +>Iterator.zipKeyed({ a: new String("ab") }).toArray : () => { a: string; }[] +>Iterator.zipKeyed({ a: new String("ab") }) : IteratorObject<{ a: string; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: new String("ab") } : { a: String; } +>a : String +>new String("ab") : String +>String : StringConstructor +>"ab" : "ab" +>toArray : () => { a: string; }[] + +const c: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); +>c : (string | undefined)[][] +>Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray() : (string | undefined)[][] +>Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray : () => (string | undefined)[][] +>Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }) : IteratorObject<(string | undefined)[], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[["a"]] : string[][] +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: new String("ab") } : { mode: "longest"; padding: String; } +>mode : "longest" +>"longest" : "longest" +>padding : String +>new String("ab") : String +>String : StringConstructor +>"ab" : "ab" +>toArray : () => (string | undefined)[][] + +const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); +>d : { a: number; }[] +>Iterator.zipKeyed({ a: [1], b: undefined }).toArray() : { a: number; }[] +>Iterator.zipKeyed({ a: [1], b: undefined }).toArray : () => { a: number; }[] +>Iterator.zipKeyed({ a: [1], b: undefined }) : IteratorObject<{ a: number; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1], b: undefined } : { a: number[]; b: undefined; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : undefined +>undefined : undefined +>toArray : () => { a: number; }[] + +const e: { a: number; }[] = d; +>e : { a: number; }[] +>a : number +>d : { a: number; }[] + +d[0].b; +>d[0].b : any +>d[0] : { a: number; } +>d : { a: number; }[] +>0 : 0 +>b : any + +const f: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); +>f : never[] +>Iterator.zipKeyed({ a: undefined }).toArray() : never[] +>Iterator.zipKeyed({ a: undefined }).toArray : () => never[] +>Iterator.zipKeyed({ a: undefined }) : IteratorObject +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: undefined } : { a: undefined; } +>a : undefined +>undefined : undefined +>toArray : () => never[] + +const g: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); +>g : never[] +>Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray() : never[] +>Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray : () => never[] +>Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }) : IteratorObject +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: undefined } : { a: undefined; } +>a : undefined +>undefined : undefined +>{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } +>mode : "longest" +>"longest" : "longest" +>padding : {} +>{} : {} +>toArray : () => never[] + +interface I { + readonly a: Iterable; +>a : Iterable + + readonly b?: Iterator; +>b : Iterator | undefined + + readonly c: Iterable | undefined; +>c : Iterable | undefined + + readonly d?: undefined; +>d : undefined +} +declare const h: I; +>h : I + +const i = Iterator.zipKeyed(h).toArray(); +>i : { a: number; b?: string; c?: boolean; }[] +>Iterator.zipKeyed(h).toArray() : { a: number; b?: string; c?: boolean; }[] +>Iterator.zipKeyed(h).toArray : () => { a: number; b?: string; c?: boolean; }[] +>Iterator.zipKeyed(h) : IteratorObject<{ a: number; b?: string; c?: boolean; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>h : I +>toArray : () => { a: number; b?: string; c?: boolean; }[] + +const j: { a: number; b?: string; c?: boolean; }[] = i; +>j : { a: number; b?: string; c?: boolean; }[] +>a : number +>b : string | undefined +>c : boolean | undefined +>i : { a: number; b?: string; c?: boolean; }[] + +i[0].a = 2; +>i[0].a = 2 : 2 +>i[0].a : number +>i[0] : { a: number; b?: string; c?: boolean; } +>i : { a: number; b?: string; c?: boolean; }[] +>0 : 0 +>a : number +>2 : 2 + +i[0].b = "a"; +>i[0].b = "a" : "a" +>i[0].b : string +>i[0] : { a: number; b?: string; c?: boolean; } +>i : { a: number; b?: string; c?: boolean; }[] +>0 : 0 +>b : string +>"a" : "a" + +i[0].c = true; +>i[0].c = true : true +>i[0].c : boolean +>i[0] : { a: number; b?: string; c?: boolean; } +>i : { a: number; b?: string; c?: boolean; }[] +>0 : 0 +>c : boolean +>true : true + +i[0].d; +>i[0].d : any +>i[0] : { a: number; b?: string; c?: boolean; } +>i : { a: number; b?: string; c?: boolean; }[] +>0 : 0 +>d : any + +const k: { a: number; c: boolean; }[] = i; +>k : { a: number; c: boolean; }[] +>a : number +>c : boolean +>i : { a: number; b?: string; c?: boolean; }[] + +const l: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); +>l : { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] +>a : number | undefined +>b : string | undefined +>c : boolean | undefined +>Iterator.zipKeyed(h, { mode: "longest" }).toArray() : { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] +>Iterator.zipKeyed(h, { mode: "longest" }).toArray : () => { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] +>Iterator.zipKeyed(h, { mode: "longest" }) : IteratorObject<{ a: number | undefined; b?: string | undefined; c?: boolean | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>h : I +>{ mode: "longest" } : { mode: "longest"; } +>mode : "longest" +>"longest" : "longest" +>toArray : () => { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] + +declare const m: { a: Iterable; } | { b: Iterator; }; +>m : { a: Iterable; } | { b: Iterator; } +>a : Iterable +>b : Iterator + +const n: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(m).toArray(); +>n : ({ a: number; } | { b: string; })[] +>a : number +>b : string +>Iterator.zipKeyed(m).toArray() : ({ a: number; } | { b: string; })[] +>Iterator.zipKeyed(m).toArray : () => ({ a: number; } | { b: string; })[] +>Iterator.zipKeyed(m) : IteratorObject<{ a: number; } | { b: string; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>m : { a: Iterable; } | { b: Iterator; } +>toArray : () => ({ a: number; } | { b: string; })[] + +declare const o: { a: Iterable; } | { b: number; }; +>o : { a: Iterable; } | { b: number; } +>a : Iterable +>b : number + +Iterator.zipKeyed(o); +>Iterator.zipKeyed(o) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>o : { a: Iterable; } | { b: number; } + +Iterator.zipKeyed(o, { mode: "longest" }); +>Iterator.zipKeyed(o, { mode: "longest" }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>o : { a: Iterable; } | { b: number; } +>{ mode: "longest" } : { mode: "longest"; } +>mode : "longest" +>"longest" : "longest" + +Iterator.zipKeyed(o, { mode: "longest", padding: {} }); +>Iterator.zipKeyed(o, { mode: "longest", padding: {} }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>o : { a: Iterable; } | { b: number; } +>{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } +>mode : "longest" +>"longest" : "longest" +>padding : {} +>{} : {} + +declare const p: { a?: Iterable; } | { b: string; }; +>p : { a?: Iterable; } | { b: string; } +>a : Iterable | undefined +>b : string + +Iterator.zipKeyed(p); +>Iterator.zipKeyed(p) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>p : { a?: Iterable; } | { b: string; } + +declare const q: { a: Iterable; } | { b: undefined; }; +>q : { a: Iterable; } | { b: undefined; } +>a : Iterable +>b : undefined + +const r: { a: number; }[] = Iterator.zipKeyed(q).toArray(); +>r : { a: number; }[] +>a : number +>Iterator.zipKeyed(q).toArray() : { a: number; }[] +>Iterator.zipKeyed(q).toArray : () => { a: number; }[] +>Iterator.zipKeyed(q) : IteratorObject<{ a: number; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>q : { a: Iterable; } | { b: undefined; } +>toArray : () => { a: number; }[] + +declare const s: unique symbol; +>s : unique symbol + +declare const t: { a: Iterable; [s]?: Iterable; }; +>t : { a: Iterable; [s]?: Iterable; } +>a : Iterable +>[s] : Iterable | undefined +>s : unique symbol + +const u: { a: number; [s]?: string; }[] = Iterator.zipKeyed(t).toArray(); +>u : { a: number; [s]?: string; }[] +>a : number +>[s] : string | undefined +>s : unique symbol +>Iterator.zipKeyed(t).toArray() : { a: number; [s]?: string; }[] +>Iterator.zipKeyed(t).toArray : () => { a: number; [s]?: string; }[] +>Iterator.zipKeyed(t) : IteratorObject<{ a: number; [s]?: string; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>t : { a: Iterable; [s]?: Iterable; } +>toArray : () => { a: number; [s]?: string; }[] + +Iterator.zipKeyed({ a: [1], b: null }); +>Iterator.zipKeyed({ a: [1], b: null }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1], b: null } : { a: number[]; b: null; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : null + +Iterator.zipKeyed({ a: [1], b: false }); +>Iterator.zipKeyed({ a: [1], b: false }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1], b: false } : { a: number[]; b: false; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : false +>false : false + +Iterator.zip([undefined]); +>Iterator.zip([undefined]) : IteratorObject +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[undefined] : [undefined] +>undefined : undefined + +declare const v: { a?: undefined; }; +>v : { a?: undefined; } +>a : undefined + +const w: never[] = Iterator.zipKeyed(v).toArray(); +>w : never[] +>Iterator.zipKeyed(v).toArray() : never[] +>Iterator.zipKeyed(v).toArray : () => never[] +>Iterator.zipKeyed(v) : IteratorObject +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>v : { a?: undefined; } +>toArray : () => never[] + +const x: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); +>x : { a: number; }[] +>a : number +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray() : { a: number; }[] +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray : () => { a: number; }[] +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }) : IteratorObject<{ a: number; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1], b: undefined } : { a: number[]; b: undefined; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : undefined +>undefined : undefined +>{ mode: "longest", padding: { a: 0 } } : { mode: "longest"; padding: { a: number; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: number; } +>{ a: 0 } : { a: number; } +>a : number +>0 : 0 +>toArray : () => { a: number; }[] + +const y: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); +>y : { a: number | undefined; }[] +>a : number | undefined +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray() : { a: number | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray : () => { a: number | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }) : IteratorObject<{ a: number | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1], b: undefined } : { a: number[]; b: undefined; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : undefined +>undefined : undefined +>{ mode: "longest" } : { mode: "longest"; } +>mode : "longest" +>"longest" : "longest" +>toArray : () => { a: number | undefined; }[] + +function f1(a: Iterable) { +>f1 : (a: Iterable) => { b: { a: T; }[]; c: [T][]; } +>a : Iterable + + const b: { a: T; }[] = Iterator.zipKeyed({ a }).toArray(); +>b : { a: T; }[] +>a : T +>Iterator.zipKeyed({ a }).toArray() : { a: T; }[] +>Iterator.zipKeyed({ a }).toArray : () => { a: T; }[] +>Iterator.zipKeyed({ a }) : IteratorObject<{ a: T; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K]; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K]; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K]; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K]; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K]; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K]; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a } : { a: Iterable; } +>a : Iterable +>toArray : () => { a: T; }[] + + const c: [T][] = Iterator.zip([a]).toArray(); +>c : [T][] +>Iterator.zip([a]).toArray() : [T][] +>Iterator.zip([a]).toArray : () => [T][] +>Iterator.zip([a]) : IteratorObject<[T], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T_1, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T_1, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T_1, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T_1 extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T_1 extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T_1, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T_1, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T_1, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T_1 extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T_1 extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[a] : [Iterable] +>a : Iterable +>toArray : () => [T][] + + return { b, c }; +>{ b, c } : { b: { a: T; }[]; c: [T][]; } +>b : { a: T; }[] +>c : [T][] +} + +// Padding + +const paddingA: [Iterable, ...Iterable[]] = [[1, 2], [3]]; +>paddingA : [Iterable, ...Iterable[]] +>[[1, 2], [3]] : [number[], number[]] +>[1, 2] : number[] +>1 : 1 +>2 : 2 +>[3] : number[] +>3 : 3 + +const paddingB = Iterator.zip(paddingA, { mode: "longest", padding: [0] }).toArray(); +>paddingB : [number, ...(number | undefined)[]][] +>Iterator.zip(paddingA, { mode: "longest", padding: [0] }).toArray() : [number, ...(number | undefined)[]][] +>Iterator.zip(paddingA, { mode: "longest", padding: [0] }).toArray : () => [number, ...(number | undefined)[]][] +>Iterator.zip(paddingA, { mode: "longest", padding: [0] }) : IteratorObject<[number, ...(number | undefined)[]], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>paddingA : [Iterable, ...Iterable[]] +>{ mode: "longest", padding: [0] } : { mode: "longest"; padding: [number]; } +>mode : "longest" +>"longest" : "longest" +>padding : [number] +>[0] : [number] +>0 : 0 +>toArray : () => [number, ...(number | undefined)[]][] + +const paddingC: (number | undefined)[][] = paddingB; +>paddingC : (number | undefined)[][] +>paddingB : [number, ...(number | undefined)[]][] + +const paddingD: number[][] = paddingB; +>paddingD : number[][] +>paddingB : [number, ...(number | undefined)[]][] + +const paddingE: Record> = { a: [1], b: [2, 3] }; +>paddingE : Record> +>{ a: [1], b: [2, 3] } : { a: number[]; b: number[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : number[] +>[2, 3] : number[] +>2 : 2 +>3 : 3 + +const paddingF = Iterator.zipKeyed(paddingE, { mode: "longest", padding: {} }).toArray(); +>paddingF : { [x: string]: number | undefined; }[] +>Iterator.zipKeyed(paddingE, { mode: "longest", padding: {} }).toArray() : { [x: string]: number | undefined; }[] +>Iterator.zipKeyed(paddingE, { mode: "longest", padding: {} }).toArray : () => { [x: string]: number | undefined; }[] +>Iterator.zipKeyed(paddingE, { mode: "longest", padding: {} }) : IteratorObject<{ [x: string]: number | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>paddingE : Record> +>{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } +>mode : "longest" +>"longest" : "longest" +>padding : {} +>{} : {} +>toArray : () => { [x: string]: number | undefined; }[] + +const paddingG: Record[] = paddingF; +>paddingG : Record[] +>paddingF : { [x: string]: number | undefined; }[] + +const paddingH: Record[] = paddingF; +>paddingH : Record[] +>paddingF : { [x: string]: number | undefined; }[] + +declare const paddingI: Record; +>paddingI : Record + +const paddingJ = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: paddingI }).toArray(); +>paddingJ : { a: number | undefined; b: number | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: paddingI }).toArray() : { a: number | undefined; b: number | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: paddingI }).toArray : () => { a: number | undefined; b: number | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: paddingI }) : IteratorObject<{ a: number | undefined; b: number | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1], b: [2, 3] } : { a: number[]; b: number[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : number[] +>[2, 3] : number[] +>2 : 2 +>3 : 3 +>{ mode: "longest", padding: paddingI } : { mode: "longest"; padding: Record; } +>mode : "longest" +>"longest" : "longest" +>padding : Record +>paddingI : Record +>toArray : () => { a: number | undefined; b: number | undefined; }[] + +const paddingK: { a: number | undefined; b: number | undefined; }[] = paddingJ; +>paddingK : { a: number | undefined; b: number | undefined; }[] +>a : number | undefined +>b : number | undefined +>paddingJ : { a: number | undefined; b: number | undefined; }[] + +const paddingL: { a: number; b: number; }[] = paddingJ; +>paddingL : { a: number; b: number; }[] +>a : number +>b : number +>paddingJ : { a: number | undefined; b: number | undefined; }[] + +const paddingM = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); +>paddingM : [number, string][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray() : [number, string][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray : () => [number, string][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }) : IteratorObject<[number, string], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] : [number[], string[]] +>[1] : number[] +>1 : 1 +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: [0, ""] } : { mode: "longest"; padding: [number, string]; } +>mode : "longest" +>"longest" : "longest" +>padding : [number, string] +>[0, ""] : [number, string] +>0 : 0 +>"" : "" +>toArray : () => [number, string][] + +const paddingN: [number, string][] = paddingM; +>paddingN : [number, string][] +>paddingM : [number, string][] + +const paddingO = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); +>paddingO : { a: number; b: string; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray() : { a: number; b: string; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray : () => { a: number; b: string; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }) : IteratorObject<{ a: number; b: string; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : string[] +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: { a: 0, b: "" } } : { mode: "longest"; padding: { a: number; b: string; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: number; b: string; } +>{ a: 0, b: "" } : { a: number; b: string; } +>a : number +>0 : 0 +>b : string +>"" : "" +>toArray : () => { a: number; b: string; }[] + +const paddingP: { a: number; b: string; }[] = paddingO; +>paddingP : { a: number; b: string; }[] +>a : number +>b : string +>paddingO : { a: number; b: string; }[] + +const paddingQ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); +>paddingQ : [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray() : [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray : () => [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }) : IteratorObject<[number, string | undefined], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] : [number[], string[]] +>[1] : number[] +>1 : 1 +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: [0] } : { mode: "longest"; padding: [number]; } +>mode : "longest" +>"longest" : "longest" +>padding : [number] +>[0] : [number] +>0 : 0 +>toArray : () => [number, string | undefined][] + +const paddingR: [number | undefined, string | undefined][] = paddingQ; +>paddingR : [number | undefined, string | undefined][] +>paddingQ : [number, string | undefined][] + +const paddingS: [number, string][] = paddingQ; +>paddingS : [number, string][] +>paddingQ : [number, string | undefined][] + +const paddingT = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); +>paddingT : { a: number; b: string | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray() : { a: number; b: string | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray : () => { a: number; b: string | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }) : IteratorObject<{ a: number; b: string | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : string[] +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: { a: 0 } } : { mode: "longest"; padding: { a: number; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: number; } +>{ a: 0 } : { a: number; } +>a : number +>0 : 0 +>toArray : () => { a: number; b: string | undefined; }[] + +const paddingU: { a: number | undefined; b: string | undefined; }[] = paddingT; +>paddingU : { a: number | undefined; b: string | undefined; }[] +>a : number | undefined +>b : string | undefined +>paddingT : { a: number; b: string | undefined; }[] + +const paddingV: { a: number; b: string; }[] = paddingT; +>paddingV : { a: number; b: string; }[] +>a : number +>b : string +>paddingT : { a: number; b: string | undefined; }[] + +declare const paddingW: readonly [number, string]; +>paddingW : readonly [number, string] + +const paddingX: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingW }).toArray(); +>paddingX : [number, string][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingW }).toArray() : [number, string][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingW }).toArray : () => [number, string][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingW }) : IteratorObject<[number, string], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] : [number[], string[]] +>[1] : number[] +>1 : 1 +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: paddingW } : { mode: "longest"; padding: readonly [number, string]; } +>mode : "longest" +>"longest" : "longest" +>padding : readonly [number, string] +>paddingW : readonly [number, string] +>toArray : () => [number, string][] + +declare const paddingY: [number, string?]; +>paddingY : [number, string?] + +const paddingZ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY }).toArray(); +>paddingZ : [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY }).toArray() : [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY }).toArray : () => [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY }) : IteratorObject<[number, string | undefined], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] : [number[], string[]] +>[1] : number[] +>1 : 1 +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: paddingY } : { mode: "longest"; padding: [number, string?]; } +>mode : "longest" +>"longest" : "longest" +>padding : [number, string?] +>paddingY : [number, string?] +>toArray : () => [number, string | undefined][] + +const paddingA1: [number, string][] = paddingZ; +>paddingA1 : [number, string][] +>paddingZ : [number, string | undefined][] + +declare const paddingB1: [Iterable] | [Iterable, Iterable]; +>paddingB1 : [Iterable] | [Iterable, Iterable] + +const paddingC1 = Iterator.zip(paddingB1, { mode: "longest", padding: [0] }).toArray(); +>paddingC1 : ([number] | [number, number | undefined])[] +>Iterator.zip(paddingB1, { mode: "longest", padding: [0] }).toArray() : ([number] | [number, number | undefined])[] +>Iterator.zip(paddingB1, { mode: "longest", padding: [0] }).toArray : () => ([number] | [number, number | undefined])[] +>Iterator.zip(paddingB1, { mode: "longest", padding: [0] }) : IteratorObject<[number] | [number, number | undefined], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>paddingB1 : [Iterable] | [Iterable, Iterable] +>{ mode: "longest", padding: [0] } : { mode: "longest"; padding: [number]; } +>mode : "longest" +>"longest" : "longest" +>padding : [number] +>[0] : [number] +>0 : 0 +>toArray : () => ([number] | [number, number | undefined])[] + +const paddingD1: number[][] = paddingC1; +>paddingD1 : number[][] +>paddingC1 : ([number] | [number, number | undefined])[] + +declare const paddingE1: { a: Iterable; } | { b: Iterable; }; +>paddingE1 : { a: Iterable; } | { b: Iterable; } +>a : Iterable +>b : Iterable + +const paddingF1 = Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: 0 } }).toArray(); +>paddingF1 : ({ a: number; } | { b: string | undefined; })[] +>Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: 0 } }).toArray() : ({ a: number; } | { b: string | undefined; })[] +>Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: 0 } }).toArray : () => ({ a: number; } | { b: string | undefined; })[] +>Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: 0 } }) : IteratorObject<{ a: number; } | { b: string | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>paddingE1 : { a: Iterable; } | { b: Iterable; } +>{ mode: "longest", padding: { a: 0 } } : { mode: "longest"; padding: { a: number; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: number; } +>{ a: 0 } : { a: number; } +>a : number +>0 : 0 +>toArray : () => ({ a: number; } | { b: string | undefined; })[] + +const paddingG1: ({ a: number; } | { b: string; })[] = paddingF1; +>paddingG1 : ({ a: number; } | { b: string; })[] +>a : number +>b : string +>paddingF1 : ({ a: number; } | { b: string | undefined; })[] + +declare const paddingH1: { a: number; } | { b: string; }; +>paddingH1 : { a: number; } | { b: string; } +>a : number +>b : string + +const paddingI1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: paddingH1 }).toArray(); +>paddingI1 : { a: number | undefined; b: string | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: paddingH1 }).toArray() : { a: number | undefined; b: string | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: paddingH1 }).toArray : () => { a: number | undefined; b: string | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: paddingH1 }) : IteratorObject<{ a: number | undefined; b: string | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : string[] +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: paddingH1 } : { mode: "longest"; padding: { a: number; } | { b: string; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: number; } | { b: string; } +>paddingH1 : { a: number; } | { b: string; } +>toArray : () => { a: number | undefined; b: string | undefined; }[] + +const paddingJ1: { a: number; b: string; }[] = paddingI1; +>paddingJ1 : { a: number; b: string; }[] +>a : number +>b : string +>paddingI1 : { a: number | undefined; b: string | undefined; }[] + +const paddingK1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); +>paddingK1 : { a: number | undefined; b: number; }[] +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray() : { a: number | undefined; b: number; }[] +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray : () => { a: number | undefined; b: number; }[] +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }) : IteratorObject<{ a: number | undefined; b: number; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1], b: [2] } : { a: number[]; b: number[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : number[] +>[2] : number[] +>2 : 2 +>{ mode: "longest", padding: { a: undefined, b: 0 } } : { mode: "longest"; padding: { a: undefined; b: number; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: undefined; b: number; } +>{ a: undefined, b: 0 } : { a: undefined; b: number; } +>a : undefined +>undefined : undefined +>b : number +>0 : 0 +>toArray : () => { a: number | undefined; b: number; }[] + +const paddingL1: { a: number; b: number; }[] = paddingK1; +>paddingL1 : { a: number; b: number; }[] +>a : number +>b : number +>paddingK1 : { a: number | undefined; b: number; }[] + +declare const paddingM1: { [K in `a${string}`]: Iterable; }; +>paddingM1 : { [x: `a${string}`]: Iterable; } + +const paddingN1 = Iterator.zipKeyed(paddingM1, { mode: "longest", padding: {} }).toArray(); +>paddingN1 : { [x: `a${string}`]: number | undefined; }[] +>Iterator.zipKeyed(paddingM1, { mode: "longest", padding: {} }).toArray() : { [x: `a${string}`]: number | undefined; }[] +>Iterator.zipKeyed(paddingM1, { mode: "longest", padding: {} }).toArray : () => { [x: `a${string}`]: number | undefined; }[] +>Iterator.zipKeyed(paddingM1, { mode: "longest", padding: {} }) : IteratorObject<{ [x: `a${string}`]: number | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>paddingM1 : { [x: `a${string}`]: Iterable; } +>{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } +>mode : "longest" +>"longest" : "longest" +>padding : {} +>{} : {} +>toArray : () => { [x: `a${string}`]: number | undefined; }[] + +const paddingO1: { [K in `a${string}`]: number; }[] = paddingN1; +>paddingO1 : { [x: `a${string}`]: number; }[] +>paddingN1 : { [x: `a${string}`]: number | undefined; }[] + +declare const paddingP1: unique symbol; +>paddingP1 : unique symbol + +const paddingQ1: { [paddingP1]: number; }[] = Iterator.zipKeyed({ [paddingP1]: [1] }, { mode: "longest", padding: { [paddingP1]: 0 } }).toArray(); +>paddingQ1 : { [paddingP1]: number; }[] +>[paddingP1] : number +>paddingP1 : unique symbol +>Iterator.zipKeyed({ [paddingP1]: [1] }, { mode: "longest", padding: { [paddingP1]: 0 } }).toArray() : { [paddingP1]: number; }[] +>Iterator.zipKeyed({ [paddingP1]: [1] }, { mode: "longest", padding: { [paddingP1]: 0 } }).toArray : () => { [paddingP1]: number; }[] +>Iterator.zipKeyed({ [paddingP1]: [1] }, { mode: "longest", padding: { [paddingP1]: 0 } }) : IteratorObject<{ [paddingP1]: number; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ [paddingP1]: [1] } : { [paddingP1]: number[]; } +>[paddingP1] : number[] +>paddingP1 : unique symbol +>[1] : number[] +>1 : 1 +>{ mode: "longest", padding: { [paddingP1]: 0 } } : { mode: "longest"; padding: { [paddingP1]: number; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { [paddingP1]: number; } +>{ [paddingP1]: 0 } : { [paddingP1]: number; } +>[paddingP1] : number +>paddingP1 : unique symbol +>0 : 0 +>toArray : () => { [paddingP1]: number; }[] + +declare const paddingR1: Record & { a: number; }; +>paddingR1 : Record & { a: number; } +>a : number + +const paddingS1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: paddingR1 }).toArray(); +>paddingS1 : { a: number; b: number | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: paddingR1 }).toArray() : { a: number; b: number | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: paddingR1 }).toArray : () => { a: number; b: number | undefined; }[] +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: paddingR1 }) : IteratorObject<{ a: number; b: number | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1], b: [2] } : { a: number[]; b: number[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : number[] +>[2] : number[] +>2 : 2 +>{ mode: "longest", padding: paddingR1 } : { mode: "longest"; padding: Record & { a: number; }; } +>mode : "longest" +>"longest" : "longest" +>padding : Record & { a: number; } +>paddingR1 : Record & { a: number; } +>toArray : () => { a: number; b: number | undefined; }[] + +const paddingT1: { a: number; b: number | undefined; }[] = paddingS1; +>paddingT1 : { a: number; b: number | undefined; }[] +>a : number +>b : number | undefined +>paddingS1 : { a: number; b: number | undefined; }[] + +const paddingU1: { a: number; b: number; }[] = paddingS1; +>paddingU1 : { a: number; b: number; }[] +>a : number +>b : number +>paddingS1 : { a: number; b: number | undefined; }[] + +declare const paddingV1: [number] | [number, string]; +>paddingV1 : [number] | [number, string] + +const paddingW1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingV1 }).toArray(); +>paddingW1 : [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingV1 }).toArray() : [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingV1 }).toArray : () => [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingV1 }) : IteratorObject<[number, string | undefined], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] : [number[], string[]] +>[1] : number[] +>1 : 1 +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: paddingV1 } : { mode: "longest"; padding: [number] | [number, string]; } +>mode : "longest" +>"longest" : "longest" +>padding : [number] | [number, string] +>paddingV1 : [number] | [number, string] +>toArray : () => [number, string | undefined][] + +const paddingX1: [number, string | undefined][] = paddingW1; +>paddingX1 : [number, string | undefined][] +>paddingW1 : [number, string | undefined][] + +const paddingY1: [number, string][] = paddingW1; +>paddingY1 : [number, string][] +>paddingW1 : [number, string | undefined][] + +const paddingZ1: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); +>paddingZ1 : [number | undefined, number][] +>Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray() : [number | undefined, number][] +>Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray : () => [number | undefined, number][] +>Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }) : IteratorObject<[number | undefined, number], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], [2]] : [number[], number[]] +>[1] : number[] +>1 : 1 +>[2] : number[] +>2 : 2 +>{ mode: "longest", padding: [undefined, 0] } : { mode: "longest"; padding: [undefined, number]; } +>mode : "longest" +>"longest" : "longest" +>padding : [undefined, number] +>[undefined, 0] : [undefined, number] +>undefined : undefined +>0 : 0 +>toArray : () => [number | undefined, number][] + +const paddingA2: { a: number | undefined; b: number; }[] = paddingK1; +>paddingA2 : { a: number | undefined; b: number; }[] +>a : number | undefined +>b : number +>paddingK1 : { a: number | undefined; b: number; }[] + +// Own properties + +class InputsWithPrototypeMembers { +>InputsWithPrototypeMembers : InputsWithPrototypeMembers + + values = [1, 2]; +>values : number[] +>[1, 2] : number[] +>1 : 1 +>2 : 2 + + get label() { +>label : string + + return "inputs"; +>"inputs" : "inputs" + } + + describe() { +>describe : () => string + + return this.label; +>this.label : string +>this : this +>label : string + } +} + +const instance = new InputsWithPrototypeMembers(); +>instance : InputsWithPrototypeMembers +>new InputsWithPrototypeMembers() : InputsWithPrototypeMembers +>InputsWithPrototypeMembers : typeof InputsWithPrototypeMembers + +const inherited = Iterator.zipKeyed(instance).toArray(); +>inherited : Record[] +>Iterator.zipKeyed(instance).toArray() : Record[] +>Iterator.zipKeyed(instance).toArray : () => Record[] +>Iterator.zipKeyed(instance) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>instance : InputsWithPrototypeMembers +>toArray : () => Record[] + +const inheritedStrict = Iterator.zipKeyed(instance, { mode: "strict" }).toArray(); +>inheritedStrict : Record[] +>Iterator.zipKeyed(instance, { mode: "strict" }).toArray() : Record[] +>Iterator.zipKeyed(instance, { mode: "strict" }).toArray : () => Record[] +>Iterator.zipKeyed(instance, { mode: "strict" }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>instance : InputsWithPrototypeMembers +>{ mode: "strict" } : { mode: "strict"; } +>mode : "strict" +>"strict" : "strict" +>toArray : () => Record[] + +const inheritedLongest = Iterator.zipKeyed(instance, { mode: "longest" }).toArray(); +>inheritedLongest : Record[] +>Iterator.zipKeyed(instance, { mode: "longest" }).toArray() : Record[] +>Iterator.zipKeyed(instance, { mode: "longest" }).toArray : () => Record[] +>Iterator.zipKeyed(instance, { mode: "longest" }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>instance : InputsWithPrototypeMembers +>{ mode: "longest" } : { mode: "longest"; } +>mode : "longest" +>"longest" : "longest" +>toArray : () => Record[] + +const inheritedPadded = Iterator.zipKeyed(instance, { mode: "longest", padding: { values: 0 } }).toArray(); +>inheritedPadded : Record[] +>Iterator.zipKeyed(instance, { mode: "longest", padding: { values: 0 } }).toArray() : Record[] +>Iterator.zipKeyed(instance, { mode: "longest", padding: { values: 0 } }).toArray : () => Record[] +>Iterator.zipKeyed(instance, { mode: "longest", padding: { values: 0 } }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>instance : InputsWithPrototypeMembers +>{ mode: "longest", padding: { values: 0 } } : { mode: "longest"; padding: { values: number; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { values: number; } +>{ values: 0 } : { values: number; } +>values : number +>0 : 0 +>toArray : () => Record[] + +const hiddenInputs = { values: [1, 2], label: "inputs" }; +>hiddenInputs : { values: number[]; label: string; } +>{ values: [1, 2], label: "inputs" } : { values: number[]; label: string; } +>values : number[] +>[1, 2] : number[] +>1 : 1 +>2 : 2 +>label : string +>"inputs" : "inputs" + +Object.defineProperty(hiddenInputs, "label", { enumerable: false }); +>Object.defineProperty(hiddenInputs, "label", { enumerable: false }) : { values: number[]; label: string; } +>Object.defineProperty : (o: T, p: PropertyKey, attributes: PropertyDescriptor & ThisType) => T +>Object : ObjectConstructor +>defineProperty : (o: T, p: PropertyKey, attributes: PropertyDescriptor & ThisType) => T +>hiddenInputs : { values: number[]; label: string; } +>"label" : "label" +>{ enumerable: false } : { enumerable: false; } +>enumerable : false +>false : false + +const nonEnumerable = Iterator.zipKeyed(hiddenInputs).toArray(); +>nonEnumerable : Record[] +>Iterator.zipKeyed(hiddenInputs).toArray() : Record[] +>Iterator.zipKeyed(hiddenInputs).toArray : () => Record[] +>Iterator.zipKeyed(hiddenInputs) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>hiddenInputs : { values: number[]; label: string; } +>toArray : () => Record[] + +const nonEnumerablePadded = Iterator.zipKeyed(hiddenInputs, { mode: "longest", padding: { values: 0 } }).toArray(); +>nonEnumerablePadded : Record[] +>Iterator.zipKeyed(hiddenInputs, { mode: "longest", padding: { values: 0 } }).toArray() : Record[] +>Iterator.zipKeyed(hiddenInputs, { mode: "longest", padding: { values: 0 } }).toArray : () => Record[] +>Iterator.zipKeyed(hiddenInputs, { mode: "longest", padding: { values: 0 } }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>hiddenInputs : { values: number[]; label: string; } +>{ mode: "longest", padding: { values: 0 } } : { mode: "longest"; padding: { values: number; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { values: number; } +>{ values: 0 } : { values: number; } +>values : number +>0 : 0 +>toArray : () => Record[] + +// The same static shape can have an enumerable non-iterator property instead. +// Such inputs are accepted by the fallback and checked at runtime. +const enumerableInputs = { values: [1, 2], label: "inputs" }; +>enumerableInputs : { values: number[]; label: string; } +>{ values: [1, 2], label: "inputs" } : { values: number[]; label: string; } +>values : number[] +>[1, 2] : number[] +>1 : 1 +>2 : 2 +>label : string +>"inputs" : "inputs" + +const enumerable = Iterator.zipKeyed(enumerableInputs).toArray(); +>enumerable : Record[] +>Iterator.zipKeyed(enumerableInputs).toArray() : Record[] +>Iterator.zipKeyed(enumerableInputs).toArray : () => Record[] +>Iterator.zipKeyed(enumerableInputs) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>enumerableInputs : { values: number[]; label: string; } +>toArray : () => Record[] + +// The array's length and methods are not enumerable own properties. +const arrayInputs = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); +>arrayInputs : Record[] +>Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray() : Record[] +>Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray : () => Record[] +>Iterator.zipKeyed([[1, 2], ["a", "b"]]) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>[[1, 2], ["a", "b"]] : (string[] | number[])[] +>[1, 2] : number[] +>1 : 1 +>2 : 2 +>["a", "b"] : string[] +>"a" : "a" +>"b" : "b" +>toArray : () => Record[] + +// The fallback must not claim that ignored properties exist on yielded objects. +const inheritedLabel: string = inherited[0].label; +>inheritedLabel : string +>inherited[0].label : unknown +>inherited[0] : Record +>inherited : Record[] +>0 : 0 +>label : unknown + +const nonEnumerableLabel: string = nonEnumerable[0].label; +>nonEnumerableLabel : string +>nonEnumerable[0].label : unknown +>nonEnumerable[0] : Record +>nonEnumerable : Record[] +>0 : 0 +>label : unknown + +// Precise record inference still handles symbol keys and padding. +declare const ownKey: unique symbol; +>ownKey : unique symbol + +const precise: { values: number; [ownKey]: string; }[] = Iterator.zipKeyed({ values: [1], [ownKey]: ["a"] }).toArray(); +>precise : { values: number; [ownKey]: string; }[] +>values : number +>[ownKey] : string +>ownKey : unique symbol +>Iterator.zipKeyed({ values: [1], [ownKey]: ["a"] }).toArray() : { values: number; [ownKey]: string; }[] +>Iterator.zipKeyed({ values: [1], [ownKey]: ["a"] }).toArray : () => { values: number; [ownKey]: string; }[] +>Iterator.zipKeyed({ values: [1], [ownKey]: ["a"] }) : IteratorObject<{ values: number; [ownKey]: string; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ values: [1], [ownKey]: ["a"] } : { values: number[]; [ownKey]: string[]; } +>values : number[] +>[1] : number[] +>1 : 1 +>[ownKey] : string[] +>ownKey : unique symbol +>["a"] : string[] +>"a" : "a" +>toArray : () => { values: number; [ownKey]: string; }[] + +const preciseLongest: { values: number | undefined; }[] = Iterator.zipKeyed({ values: [1] }, { mode: "longest" }).toArray(); +>preciseLongest : { values: number | undefined; }[] +>values : number | undefined +>Iterator.zipKeyed({ values: [1] }, { mode: "longest" }).toArray() : { values: number | undefined; }[] +>Iterator.zipKeyed({ values: [1] }, { mode: "longest" }).toArray : () => { values: number | undefined; }[] +>Iterator.zipKeyed({ values: [1] }, { mode: "longest" }) : IteratorObject<{ values: number | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ values: [1] } : { values: number[]; } +>values : number[] +>[1] : number[] +>1 : 1 +>{ mode: "longest" } : { mode: "longest"; } +>mode : "longest" +>"longest" : "longest" +>toArray : () => { values: number | undefined; }[] + +const precisePadded: { values: number; }[] = Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: 0 } }).toArray(); +>precisePadded : { values: number; }[] +>values : number +>Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: 0 } }).toArray() : { values: number; }[] +>Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: 0 } }).toArray : () => { values: number; }[] +>Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: 0 } }) : IteratorObject<{ values: number; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ values: [1] } : { values: number[]; } +>values : number[] +>[1] : number[] +>1 : 1 +>{ mode: "longest", padding: { values: 0 } } : { mode: "longest"; padding: { values: number; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { values: number; } +>{ values: 0 } : { values: number; } +>values : number +>0 : 0 +>toArray : () => { values: number; }[] + +const emptyOwnProperties: never[] = Iterator.zipKeyed({}).toArray(); +>emptyOwnProperties : never[] +>Iterator.zipKeyed({}).toArray() : never[] +>Iterator.zipKeyed({}).toArray : () => never[] +>Iterator.zipKeyed({}) : IteratorObject +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{} : {} +>toArray : () => never[] + +Iterator.zipKeyed(0); +>Iterator.zipKeyed(0) : IteratorObject +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>0 : 0 + +Iterator.zipKeyed(null); +>Iterator.zipKeyed(null) : IteratorObject +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } + +Iterator.zipKeyed(instance, { mode: "invalid" }); +>Iterator.zipKeyed(instance, { mode: "invalid" }) : IteratorObject<{ values: number; label: never; describe: never; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>instance : InputsWithPrototypeMembers +>{ mode: "invalid" } : { mode: "invalid"; } +>mode : "invalid" +>"invalid" : "invalid" + +Iterator.zipKeyed(instance, { mode: "shortest", padding: {} }); +>Iterator.zipKeyed(instance, { mode: "shortest", padding: {} }) : IteratorObject<{ values: number; label: never; describe: never; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>instance : InputsWithPrototypeMembers +>{ mode: "shortest", padding: {} } : { mode: "shortest"; padding: {}; } +>mode : "shortest" +>"shortest" : "shortest" +>padding : {} +>{} : {} + +Iterator.zipKeyed(instance, { mode: "longest", padding: 0 }); +>Iterator.zipKeyed(instance, { mode: "longest", padding: 0 }) : IteratorObject<{ values: number; label: never; describe: never; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>instance : InputsWithPrototypeMembers +>{ mode: "longest", padding: 0 } : { mode: "longest"; padding: number; } +>mode : "longest" +>"longest" : "longest" +>padding : number +>0 : 0 + +Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: "invalid" } }); +>Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: "invalid" } }) : IteratorObject<{ values: number; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ values: [1] } : { values: number[]; } +>values : number[] +>[1] : number[] +>1 : 1 +>{ mode: "longest", padding: { values: "invalid" } } : { mode: "longest"; padding: { values: string; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { values: string; } +>{ values: "invalid" } : { values: string; } +>values : string +>"invalid" : "invalid" + diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip.errors.txt b/tsc/testdata/baselines/reference/compiler/iteratorZip.errors.txt deleted file mode 100644 index 9779d2d2cda6a..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/iteratorZip.errors.txt +++ /dev/null @@ -1,130 +0,0 @@ -iteratorZip.ts(62,23): error TS2769: No overload matches this call. - The last overload gave the following error. - Type '"invalid"' is not assignable to type '"longest" | "shortest" | "strict" | undefined'. -iteratorZip.ts(64,56): error TS2769: No overload matches this call. - The last overload gave the following error. - Type 'true[]' is not assignable to type 'Iterable<"a" | 1 | undefined> & object'. - Type 'true[]' is not assignable to type 'Iterable<"a" | 1 | undefined>'. - The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. - Type 'IteratorResult' is not assignable to type 'IteratorResult<"a" | 1 | undefined, any>'. - Type 'IteratorYieldResult' is not assignable to type 'IteratorResult<"a" | 1 | undefined, any>'. - Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult<"a" | 1 | undefined>'. - Type 'true' is not assignable to type '"a" | 1 | undefined'. -iteratorZip.ts(66,41): error TS2769: No overload matches this call. - The last overload gave the following error. - Object literal may only specify known properties, and 'padding' does not exist in type 'IteratorZipShortestOptions'. -iteratorZip.ts(68,14): error TS2769: No overload matches this call. - The last overload gave the following error. - Argument of type 'number' is not assignable to parameter of type 'Iterable> & object'. - Type 'number' is not assignable to type 'Iterable>'. -iteratorZip.ts(70,21): error TS2322: Type 'number' is not assignable to type 'never'. - - -==== iteratorZip.ts (5 errors) ==== - declare const key: unique symbol; - - const tuples: [number, string][] = Iterator.zip([ - [1, 2], - new Set(["a", "b"]), - ] as const).toArray(); - - tuples[0][0] = 2; - - const shortestTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray(); - const strictTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray(); - const longestTuplesWithPadding: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray(); - const longestTuplesWithoutPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray(); - const longestTuplesWithPartialPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray(); - - declare const maybeLongestOptions: { mode: "shortest"; } | { mode: "longest"; }; - const maybeLongestTuples: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray(); - - const empty: never[] = Iterator.zip([]).toArray(); - const emptyLongest: never[] = Iterator.zip([], { mode: "longest" }).toArray(); - - declare const iterables: Iterable>; - const arrays: number[][] = Iterator.zip(iterables).toArray(); - const longestArrays: (number | undefined)[][] = Iterator.zip(iterables, { mode: "longest" }).toArray(); - const maybeLongestArrays: (number | undefined)[][] = Iterator.zip(iterables, maybeLongestOptions).toArray(); - - declare const iterableArray: Iterable[]; - const longestArrayWithPadding: (number | undefined)[][] = Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray(); - - const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ - a: [1, 2], - b: new Set(["a", "b"]), - [key]: [true, false], - } as const).toArray(); - - objects[0].a = 2; - - const longestObjectsWithPadding: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { - mode: "longest", - padding: { a: 1, b: "a" }, - }).toArray(); - - const longestObjectsWithoutPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { - mode: "longest", - }).toArray(); - - const longestObjectsWithPartialPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { - mode: "longest", - padding: { b: "a" }, - }).toArray(); - - const maybeLongestObjects: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray(); - - interface Inputs { - a: Iterable; - b: Iterator; - } - - declare const inputs: Inputs; - const rows: { a: number; b: string; }[] = Iterator.zipKeyed(inputs).toArray(); - - Iterator.zip([[1]], { mode: "invalid" }); - ~~~~ -!!! error TS2769: No overload matches this call. -!!! error TS2769: The last overload gave the following error. -!!! error TS2769: Type '"invalid"' is not assignable to type '"longest" | "shortest" | "strict" | undefined'. -!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. - - Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }); - ~~~~~~~ -!!! error TS2769: No overload matches this call. -!!! error TS2769: The last overload gave the following error. -!!! error TS2769: Type 'true[]' is not assignable to type 'Iterable<"a" | 1 | undefined> & object'. -!!! error TS2769: Type 'true[]' is not assignable to type 'Iterable<"a" | 1 | undefined>'. -!!! error TS2769: The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. -!!! error TS2769: Type 'IteratorResult' is not assignable to type 'IteratorResult<"a" | 1 | undefined, any>'. -!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorResult<"a" | 1 | undefined, any>'. -!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult<"a" | 1 | undefined>'. -!!! error TS2769: Type 'true' is not assignable to type '"a" | 1 | undefined'. -!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. - - Iterator.zip([[1]], { mode: "shortest", padding: [1] }); - ~~~~~~~ -!!! error TS2769: No overload matches this call. -!!! error TS2769: The last overload gave the following error. -!!! error TS2769: Object literal may only specify known properties, and 'padding' does not exist in type 'IteratorZipShortestOptions'. -!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. - - Iterator.zip(0); - ~ -!!! error TS2769: No overload matches this call. -!!! error TS2769: The last overload gave the following error. -!!! error TS2769: Argument of type 'number' is not assignable to parameter of type 'Iterable> & object'. -!!! error TS2769: Type 'number' is not assignable to type 'Iterable>'. -!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. - - Iterator.zipKeyed({ a: 0 }); - ~ -!!! error TS2322: Type 'number' is not assignable to type 'never'. -!!! related TS6500 iteratorZip.ts:70:21: The expected type comes from property 'a' which is declared here on type '{ a: number; } & IteratorZipKeyedInput<{ a: number; }>' - - const emptyKeyed: never[] = Iterator.zipKeyed({}).toArray(); - const emptyKeyedLongest: never[] = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); - - declare const unionInputs: { a: Iterable; } | { b: Iterator; }; - const unionRows: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(unionInputs).toArray(); - \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip.js b/tsc/testdata/baselines/reference/compiler/iteratorZip.js deleted file mode 100644 index 1778dfc79897e..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/iteratorZip.js +++ /dev/null @@ -1,127 +0,0 @@ -//// [tests/cases/compiler/iteratorZip.ts] //// - -//// [iteratorZip.ts] -declare const key: unique symbol; - -const tuples: [number, string][] = Iterator.zip([ - [1, 2], - new Set(["a", "b"]), -] as const).toArray(); - -tuples[0][0] = 2; - -const shortestTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray(); -const strictTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray(); -const longestTuplesWithPadding: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray(); -const longestTuplesWithoutPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray(); -const longestTuplesWithPartialPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray(); - -declare const maybeLongestOptions: { mode: "shortest"; } | { mode: "longest"; }; -const maybeLongestTuples: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray(); - -const empty: never[] = Iterator.zip([]).toArray(); -const emptyLongest: never[] = Iterator.zip([], { mode: "longest" }).toArray(); - -declare const iterables: Iterable>; -const arrays: number[][] = Iterator.zip(iterables).toArray(); -const longestArrays: (number | undefined)[][] = Iterator.zip(iterables, { mode: "longest" }).toArray(); -const maybeLongestArrays: (number | undefined)[][] = Iterator.zip(iterables, maybeLongestOptions).toArray(); - -declare const iterableArray: Iterable[]; -const longestArrayWithPadding: (number | undefined)[][] = Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray(); - -const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ - a: [1, 2], - b: new Set(["a", "b"]), - [key]: [true, false], -} as const).toArray(); - -objects[0].a = 2; - -const longestObjectsWithPadding: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { - mode: "longest", - padding: { a: 1, b: "a" }, -}).toArray(); - -const longestObjectsWithoutPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { - mode: "longest", -}).toArray(); - -const longestObjectsWithPartialPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { - mode: "longest", - padding: { b: "a" }, -}).toArray(); - -const maybeLongestObjects: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray(); - -interface Inputs { - a: Iterable; - b: Iterator; -} - -declare const inputs: Inputs; -const rows: { a: number; b: string; }[] = Iterator.zipKeyed(inputs).toArray(); - -Iterator.zip([[1]], { mode: "invalid" }); - -Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }); - -Iterator.zip([[1]], { mode: "shortest", padding: [1] }); - -Iterator.zip(0); - -Iterator.zipKeyed({ a: 0 }); - -const emptyKeyed: never[] = Iterator.zipKeyed({}).toArray(); -const emptyKeyedLongest: never[] = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); - -declare const unionInputs: { a: Iterable; } | { b: Iterator; }; -const unionRows: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(unionInputs).toArray(); - - -//// [iteratorZip.js] -"use strict"; -const tuples = Iterator.zip([ - [1, 2], - new Set(["a", "b"]), -]).toArray(); -tuples[0][0] = 2; -const shortestTuples = Iterator.zip([[1], ["a"]], { mode: "shortest" }).toArray(); -const strictTuples = Iterator.zip([[1], ["a"]], { mode: "strict" }).toArray(); -const longestTuplesWithPadding = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [1, "a"] }).toArray(); -const longestTuplesWithoutPadding = Iterator.zip([[1], ["a"]], { mode: "longest" }).toArray(); -const longestTuplesWithPartialPadding = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [1] }).toArray(); -const maybeLongestTuples = Iterator.zip([[1], ["a"]], maybeLongestOptions).toArray(); -const empty = Iterator.zip([]).toArray(); -const emptyLongest = Iterator.zip([], { mode: "longest" }).toArray(); -const arrays = Iterator.zip(iterables).toArray(); -const longestArrays = Iterator.zip(iterables, { mode: "longest" }).toArray(); -const maybeLongestArrays = Iterator.zip(iterables, maybeLongestOptions).toArray(); -const longestArrayWithPadding = Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray(); -const objects = Iterator.zipKeyed({ - a: [1, 2], - b: new Set(["a", "b"]), - [key]: [true, false], -}).toArray(); -objects[0].a = 2; -const longestObjectsWithPadding = Iterator.zipKeyed({ a: [1], b: ["a"] }, { - mode: "longest", - padding: { a: 1, b: "a" }, -}).toArray(); -const longestObjectsWithoutPadding = Iterator.zipKeyed({ a: [1], b: ["a"] }, { - mode: "longest", -}).toArray(); -const longestObjectsWithPartialPadding = Iterator.zipKeyed({ a: [1], b: ["a"] }, { - mode: "longest", - padding: { b: "a" }, -}).toArray(); -const maybeLongestObjects = Iterator.zipKeyed({ a: [1], b: ["a"] }, maybeLongestOptions).toArray(); -const rows = Iterator.zipKeyed(inputs).toArray(); -Iterator.zip([[1]], { mode: "invalid" }); -Iterator.zip([[1], ["a"]], { mode: "longest", padding: [true] }); -Iterator.zip([[1]], { mode: "shortest", padding: [1] }); -Iterator.zip(0); -Iterator.zipKeyed({ a: 0 }); -const emptyKeyed = Iterator.zipKeyed({}).toArray(); -const emptyKeyedLongest = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); -const unionRows = Iterator.zipKeyed(unionInputs).toArray(); diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip.symbols b/tsc/testdata/baselines/reference/compiler/iteratorZip.symbols deleted file mode 100644 index 756edf1dab36c..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/iteratorZip.symbols +++ /dev/null @@ -1,361 +0,0 @@ -//// [tests/cases/compiler/iteratorZip.ts] //// - -=== iteratorZip.ts === -declare const key: unique symbol; ->key : Symbol(key, Decl(iteratorZip.ts, 0, 13)) - -const tuples: [number, string][] = Iterator.zip([ ->tuples : Symbol(tuples, Decl(iteratorZip.ts, 2, 5)) ->Iterator.zip([ [1, 2], new Set(["a", "b"]),] as const).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) - - [1, 2], - new Set(["a", "b"]), ->Set : Symbol(Set, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) - -] as const).toArray(); ->const : Symbol(const) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -tuples[0][0] = 2; ->tuples : Symbol(tuples, Decl(iteratorZip.ts, 2, 5)) ->0 : Symbol(0) - -const shortestTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray(); ->shortestTuples : Symbol(shortestTuples, Decl(iteratorZip.ts, 9, 5)) ->Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->const : Symbol(const) ->mode : Symbol(mode, Decl(iteratorZip.ts, 9, 80)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const strictTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray(); ->strictTuples : Symbol(strictTuples, Decl(iteratorZip.ts, 10, 5)) ->Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->const : Symbol(const) ->mode : Symbol(mode, Decl(iteratorZip.ts, 10, 78)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const longestTuplesWithPadding: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray(); ->longestTuplesWithPadding : Symbol(longestTuplesWithPadding, Decl(iteratorZip.ts, 11, 5)) ->Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->const : Symbol(const) ->mode : Symbol(mode, Decl(iteratorZip.ts, 11, 90)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 11, 107)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const longestTuplesWithoutPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray(); ->longestTuplesWithoutPadding : Symbol(longestTuplesWithoutPadding, Decl(iteratorZip.ts, 12, 5)) ->Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->const : Symbol(const) ->mode : Symbol(mode, Decl(iteratorZip.ts, 12, 117)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const longestTuplesWithPartialPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray(); ->longestTuplesWithPartialPadding : Symbol(longestTuplesWithPartialPadding, Decl(iteratorZip.ts, 13, 5)) ->Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->const : Symbol(const) ->mode : Symbol(mode, Decl(iteratorZip.ts, 13, 121)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 13, 138)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -declare const maybeLongestOptions: { mode: "shortest"; } | { mode: "longest"; }; ->maybeLongestOptions : Symbol(maybeLongestOptions, Decl(iteratorZip.ts, 15, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 15, 36)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 15, 60)) - -const maybeLongestTuples: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray(); ->maybeLongestTuples : Symbol(maybeLongestTuples, Decl(iteratorZip.ts, 16, 5)) ->Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->const : Symbol(const) ->maybeLongestOptions : Symbol(maybeLongestOptions, Decl(iteratorZip.ts, 15, 13)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const empty: never[] = Iterator.zip([]).toArray(); ->empty : Symbol(empty, Decl(iteratorZip.ts, 18, 5)) ->Iterator.zip([]).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const emptyLongest: never[] = Iterator.zip([], { mode: "longest" }).toArray(); ->emptyLongest : Symbol(emptyLongest, Decl(iteratorZip.ts, 19, 5)) ->Iterator.zip([], { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 19, 48)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -declare const iterables: Iterable>; ->iterables : Symbol(iterables, Decl(iteratorZip.ts, 21, 13)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) - -const arrays: number[][] = Iterator.zip(iterables).toArray(); ->arrays : Symbol(arrays, Decl(iteratorZip.ts, 22, 5)) ->Iterator.zip(iterables).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->iterables : Symbol(iterables, Decl(iteratorZip.ts, 21, 13)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const longestArrays: (number | undefined)[][] = Iterator.zip(iterables, { mode: "longest" }).toArray(); ->longestArrays : Symbol(longestArrays, Decl(iteratorZip.ts, 23, 5)) ->Iterator.zip(iterables, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->iterables : Symbol(iterables, Decl(iteratorZip.ts, 21, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 23, 73)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const maybeLongestArrays: (number | undefined)[][] = Iterator.zip(iterables, maybeLongestOptions).toArray(); ->maybeLongestArrays : Symbol(maybeLongestArrays, Decl(iteratorZip.ts, 24, 5)) ->Iterator.zip(iterables, maybeLongestOptions).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->iterables : Symbol(iterables, Decl(iteratorZip.ts, 21, 13)) ->maybeLongestOptions : Symbol(maybeLongestOptions, Decl(iteratorZip.ts, 15, 13)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -declare const iterableArray: Iterable[]; ->iterableArray : Symbol(iterableArray, Decl(iteratorZip.ts, 26, 13)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) - -const longestArrayWithPadding: (number | undefined)[][] = Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray(); ->longestArrayWithPadding : Symbol(longestArrayWithPadding, Decl(iteratorZip.ts, 27, 5)) ->Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->iterableArray : Symbol(iterableArray, Decl(iteratorZip.ts, 26, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 27, 87)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 27, 104)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ ->objects : Symbol(objects, Decl(iteratorZip.ts, 29, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 29, 16)) ->b : Symbol(b, Decl(iteratorZip.ts, 29, 27)) ->[key] : Symbol([key], Decl(iteratorZip.ts, 29, 38)) ->key : Symbol(key, Decl(iteratorZip.ts, 0, 13)) ->Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) - - a: [1, 2], ->a : Symbol(a, Decl(iteratorZip.ts, 29, 80)) - - b: new Set(["a", "b"]), ->b : Symbol(b, Decl(iteratorZip.ts, 30, 14)) ->Set : Symbol(Set, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) - - [key]: [true, false], ->[key] : Symbol([key], Decl(iteratorZip.ts, 31, 27)) ->key : Symbol(key, Decl(iteratorZip.ts, 0, 13)) - -} as const).toArray(); ->const : Symbol(const) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -objects[0].a = 2; ->objects[0].a : Symbol(a, Decl(iteratorZip.ts, 29, 16)) ->objects : Symbol(objects, Decl(iteratorZip.ts, 29, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 29, 16)) - -const longestObjectsWithPadding: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { ->longestObjectsWithPadding : Symbol(longestObjectsWithPadding, Decl(iteratorZip.ts, 37, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 37, 34)) ->b : Symbol(b, Decl(iteratorZip.ts, 37, 45)) ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 37, 82)) ->b : Symbol(b, Decl(iteratorZip.ts, 37, 90)) ->const : Symbol(const) - - mode: "longest", ->mode : Symbol(mode, Decl(iteratorZip.ts, 37, 113)) - - padding: { a: 1, b: "a" }, ->padding : Symbol(padding, Decl(iteratorZip.ts, 38, 20)) ->a : Symbol(a, Decl(iteratorZip.ts, 39, 14)) ->b : Symbol(b, Decl(iteratorZip.ts, 39, 20)) - -}).toArray(); ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const longestObjectsWithoutPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { ->longestObjectsWithoutPadding : Symbol(longestObjectsWithoutPadding, Decl(iteratorZip.ts, 42, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 42, 37)) ->b : Symbol(b, Decl(iteratorZip.ts, 42, 60)) ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 42, 109)) ->b : Symbol(b, Decl(iteratorZip.ts, 42, 117)) ->const : Symbol(const) - - mode: "longest", ->mode : Symbol(mode, Decl(iteratorZip.ts, 42, 140)) - -}).toArray(); ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const longestObjectsWithPartialPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { ->longestObjectsWithPartialPadding : Symbol(longestObjectsWithPartialPadding, Decl(iteratorZip.ts, 46, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 46, 41)) ->b : Symbol(b, Decl(iteratorZip.ts, 46, 64)) ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 46, 113)) ->b : Symbol(b, Decl(iteratorZip.ts, 46, 121)) ->const : Symbol(const) - - mode: "longest", ->mode : Symbol(mode, Decl(iteratorZip.ts, 46, 144)) - - padding: { b: "a" }, ->padding : Symbol(padding, Decl(iteratorZip.ts, 47, 20)) ->b : Symbol(b, Decl(iteratorZip.ts, 48, 14)) - -}).toArray(); ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const maybeLongestObjects: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray(); ->maybeLongestObjects : Symbol(maybeLongestObjects, Decl(iteratorZip.ts, 51, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 51, 28)) ->b : Symbol(b, Decl(iteratorZip.ts, 51, 51)) ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 51, 100)) ->b : Symbol(b, Decl(iteratorZip.ts, 51, 108)) ->const : Symbol(const) ->maybeLongestOptions : Symbol(maybeLongestOptions, Decl(iteratorZip.ts, 15, 13)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -interface Inputs { ->Inputs : Symbol(Inputs, Decl(iteratorZip.ts, 51, 161)) - - a: Iterable; ->a : Symbol(Inputs.a, Decl(iteratorZip.ts, 53, 18)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) - - b: Iterator; ->b : Symbol(Inputs.b, Decl(iteratorZip.ts, 54, 24)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) -} - -declare const inputs: Inputs; ->inputs : Symbol(inputs, Decl(iteratorZip.ts, 58, 13)) ->Inputs : Symbol(Inputs, Decl(iteratorZip.ts, 51, 161)) - -const rows: { a: number; b: string; }[] = Iterator.zipKeyed(inputs).toArray(); ->rows : Symbol(rows, Decl(iteratorZip.ts, 59, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 59, 13)) ->b : Symbol(b, Decl(iteratorZip.ts, 59, 24)) ->Iterator.zipKeyed(inputs).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->inputs : Symbol(inputs, Decl(iteratorZip.ts, 58, 13)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -Iterator.zip([[1]], { mode: "invalid" }); ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 61, 21)) - -Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }); ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->const : Symbol(const) ->mode : Symbol(mode, Decl(iteratorZip.ts, 63, 37)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 63, 54)) - -Iterator.zip([[1]], { mode: "shortest", padding: [1] }); ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 65, 21)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 65, 39)) - -Iterator.zip(0); ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) - -Iterator.zipKeyed({ a: 0 }); ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 69, 19)) - -const emptyKeyed: never[] = Iterator.zipKeyed({}).toArray(); ->emptyKeyed : Symbol(emptyKeyed, Decl(iteratorZip.ts, 71, 5)) ->Iterator.zipKeyed({}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const emptyKeyedLongest: never[] = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); ->emptyKeyedLongest : Symbol(emptyKeyedLongest, Decl(iteratorZip.ts, 72, 5)) ->Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 72, 58)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 72, 75)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -declare const unionInputs: { a: Iterable; } | { b: Iterator; }; ->unionInputs : Symbol(unionInputs, Decl(iteratorZip.ts, 74, 13)) ->a : Symbol(a, Decl(iteratorZip.ts, 74, 28)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->b : Symbol(b, Decl(iteratorZip.ts, 74, 55)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) - -const unionRows: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(unionInputs).toArray(); ->unionRows : Symbol(unionRows, Decl(iteratorZip.ts, 75, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 75, 19)) ->b : Symbol(b, Decl(iteratorZip.ts, 75, 36)) ->Iterator.zipKeyed(unionInputs).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->unionInputs : Symbol(unionInputs, Decl(iteratorZip.ts, 74, 13)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip.types b/tsc/testdata/baselines/reference/compiler/iteratorZip.types deleted file mode 100644 index e2cb32e858091..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/iteratorZip.types +++ /dev/null @@ -1,543 +0,0 @@ -//// [tests/cases/compiler/iteratorZip.ts] //// - -=== iteratorZip.ts === -declare const key: unique symbol; ->key : unique symbol - -const tuples: [number, string][] = Iterator.zip([ ->tuples : [number, string][] ->Iterator.zip([ [1, 2], new Set(["a", "b"]),] as const).toArray() : [1 | 2, string][] ->Iterator.zip([ [1, 2], new Set(["a", "b"]),] as const).toArray : () => [1 | 2, string][] ->Iterator.zip([ [1, 2], new Set(["a", "b"]),] as const) : IteratorObject<[1 | 2, string], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->[ [1, 2], new Set(["a", "b"]),] as const : [readonly [1, 2], Set] ->[ [1, 2], new Set(["a", "b"]),] : [readonly [1, 2], Set] - - [1, 2], ->[1, 2] : readonly [1, 2] ->1 : 1 ->2 : 2 - - new Set(["a", "b"]), ->new Set(["a", "b"]) : Set ->Set : SetConstructor ->["a", "b"] : string[] ->"a" : "a" ->"b" : "b" - -] as const).toArray(); ->toArray : () => [1 | 2, string][] - -tuples[0][0] = 2; ->tuples[0][0] = 2 : 2 ->tuples[0][0] : number ->tuples[0] : [number, string] ->tuples : [number, string][] ->0 : 0 ->0 : 0 ->2 : 2 - -const shortestTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray(); ->shortestTuples : [number, string][] ->Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray() : [1, "a"][] ->Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray : () => [1, "a"][] ->Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }) : IteratorObject<[1, "a"], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->[[1], ["a"]] as const : [readonly [1], readonly ["a"]] ->[[1], ["a"]] : [readonly [1], readonly ["a"]] ->[1] : readonly [1] ->1 : 1 ->["a"] : readonly ["a"] ->"a" : "a" ->{ mode: "shortest" } : { mode: "shortest"; } ->mode : "shortest" ->"shortest" : "shortest" ->toArray : () => [1, "a"][] - -const strictTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray(); ->strictTuples : [number, string][] ->Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray() : [1, "a"][] ->Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray : () => [1, "a"][] ->Iterator.zip([[1], ["a"]] as const, { mode: "strict" }) : IteratorObject<[1, "a"], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->[[1], ["a"]] as const : [readonly [1], readonly ["a"]] ->[[1], ["a"]] : [readonly [1], readonly ["a"]] ->[1] : readonly [1] ->1 : 1 ->["a"] : readonly ["a"] ->"a" : "a" ->{ mode: "strict" } : { mode: "strict"; } ->mode : "strict" ->"strict" : "strict" ->toArray : () => [1, "a"][] - -const longestTuplesWithPadding: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray(); ->longestTuplesWithPadding : [number, string][] ->Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray() : [number, string][] ->Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray : () => [number, string][] ->Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }) : IteratorObject<[number, string], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->[[1], ["a"]] as const : [readonly [1], readonly ["a"]] ->[[1], ["a"]] : [readonly [1], readonly ["a"]] ->[1] : readonly [1] ->1 : 1 ->["a"] : readonly ["a"] ->"a" : "a" ->{ mode: "longest", padding: [1, "a"] } : { mode: "longest"; padding: [1, "a"]; } ->mode : "longest" ->"longest" : "longest" ->padding : [1, "a"] ->[1, "a"] : [1, "a"] ->1 : 1 ->"a" : "a" ->toArray : () => [number, string][] - -const longestTuplesWithoutPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray(); ->longestTuplesWithoutPadding : [number | undefined, string | undefined][] ->Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray() : [1 | undefined, "a" | undefined][] ->Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray : () => [1 | undefined, "a" | undefined][] ->Iterator.zip([[1], ["a"]] as const, { mode: "longest" }) : IteratorObject<[1 | undefined, "a" | undefined], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->[[1], ["a"]] as const : [readonly [1], readonly ["a"]] ->[[1], ["a"]] : [readonly [1], readonly ["a"]] ->[1] : readonly [1] ->1 : 1 ->["a"] : readonly ["a"] ->"a" : "a" ->{ mode: "longest" } : { mode: "longest"; } ->mode : "longest" ->"longest" : "longest" ->toArray : () => [1 | undefined, "a" | undefined][] - -const longestTuplesWithPartialPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray(); ->longestTuplesWithPartialPadding : [number | undefined, string | undefined][] ->Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray() : [number, "a" | undefined][] ->Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray : () => [number, "a" | undefined][] ->Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }) : IteratorObject<[number, "a" | undefined], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->[[1], ["a"]] as const : [readonly [1], readonly ["a"]] ->[[1], ["a"]] : [readonly [1], readonly ["a"]] ->[1] : readonly [1] ->1 : 1 ->["a"] : readonly ["a"] ->"a" : "a" ->{ mode: "longest", padding: [1] } : { mode: "longest"; padding: [1]; } ->mode : "longest" ->"longest" : "longest" ->padding : [1] ->[1] : [1] ->1 : 1 ->toArray : () => [number, "a" | undefined][] - -declare const maybeLongestOptions: { mode: "shortest"; } | { mode: "longest"; }; ->maybeLongestOptions : { mode: "shortest"; } | { mode: "longest"; } ->mode : "shortest" ->mode : "longest" - -const maybeLongestTuples: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray(); ->maybeLongestTuples : [number | undefined, string | undefined][] ->Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray() : [1 | undefined, "a" | undefined][] ->Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray : () => [1 | undefined, "a" | undefined][] ->Iterator.zip([[1], ["a"]] as const, maybeLongestOptions) : IteratorObject<[1 | undefined, "a" | undefined], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->[[1], ["a"]] as const : [readonly [1], readonly ["a"]] ->[[1], ["a"]] : [readonly [1], readonly ["a"]] ->[1] : readonly [1] ->1 : 1 ->["a"] : readonly ["a"] ->"a" : "a" ->maybeLongestOptions : { mode: "shortest"; } | { mode: "longest"; } ->toArray : () => [1 | undefined, "a" | undefined][] - -const empty: never[] = Iterator.zip([]).toArray(); ->empty : never[] ->Iterator.zip([]).toArray() : never[] ->Iterator.zip([]).toArray : () => never[] ->Iterator.zip([]) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->[] : [] ->toArray : () => never[] - -const emptyLongest: never[] = Iterator.zip([], { mode: "longest" }).toArray(); ->emptyLongest : never[] ->Iterator.zip([], { mode: "longest" }).toArray() : never[] ->Iterator.zip([], { mode: "longest" }).toArray : () => never[] ->Iterator.zip([], { mode: "longest" }) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->[] : [] ->{ mode: "longest" } : { mode: "longest"; } ->mode : "longest" ->"longest" : "longest" ->toArray : () => never[] - -declare const iterables: Iterable>; ->iterables : Iterable> - -const arrays: number[][] = Iterator.zip(iterables).toArray(); ->arrays : number[][] ->Iterator.zip(iterables).toArray() : number[][] ->Iterator.zip(iterables).toArray : () => number[][] ->Iterator.zip(iterables) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->iterables : Iterable> ->toArray : () => number[][] - -const longestArrays: (number | undefined)[][] = Iterator.zip(iterables, { mode: "longest" }).toArray(); ->longestArrays : (number | undefined)[][] ->Iterator.zip(iterables, { mode: "longest" }).toArray() : (number | undefined)[][] ->Iterator.zip(iterables, { mode: "longest" }).toArray : () => (number | undefined)[][] ->Iterator.zip(iterables, { mode: "longest" }) : IteratorObject<(number | undefined)[], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->iterables : Iterable> ->{ mode: "longest" } : { mode: "longest"; } ->mode : "longest" ->"longest" : "longest" ->toArray : () => (number | undefined)[][] - -const maybeLongestArrays: (number | undefined)[][] = Iterator.zip(iterables, maybeLongestOptions).toArray(); ->maybeLongestArrays : (number | undefined)[][] ->Iterator.zip(iterables, maybeLongestOptions).toArray() : (number | undefined)[][] ->Iterator.zip(iterables, maybeLongestOptions).toArray : () => (number | undefined)[][] ->Iterator.zip(iterables, maybeLongestOptions) : IteratorObject<(number | undefined)[], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->iterables : Iterable> ->maybeLongestOptions : { mode: "shortest"; } | { mode: "longest"; } ->toArray : () => (number | undefined)[][] - -declare const iterableArray: Iterable[]; ->iterableArray : Iterable[] - -const longestArrayWithPadding: (number | undefined)[][] = Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray(); ->longestArrayWithPadding : (number | undefined)[][] ->Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray() : (number | undefined)[][] ->Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray : () => (number | undefined)[][] ->Iterator.zip(iterableArray, { mode: "longest", padding: [] }) : IteratorObject<(number | undefined)[], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->iterableArray : Iterable[] ->{ mode: "longest", padding: [] } : { mode: "longest"; padding: []; } ->mode : "longest" ->"longest" : "longest" ->padding : [] ->[] : [] ->toArray : () => (number | undefined)[][] - -const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ ->objects : { a: number; b: string; [key]: boolean; }[] ->a : number ->b : string ->[key] : boolean ->key : unique symbol ->Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const).toArray() : { a: 1 | 2; b: string; [key]: boolean; }[] ->Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const).toArray : () => { a: 1 | 2; b: string; [key]: boolean; }[] ->Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const) : IteratorObject<{ a: 1 | 2; b: string; [key]: boolean; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const : { readonly a: readonly [1, 2]; readonly b: Set; readonly [key]: readonly [true, false]; } ->{ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} : { readonly a: readonly [1, 2]; readonly b: Set; readonly [key]: readonly [true, false]; } - - a: [1, 2], ->a : readonly [1, 2] ->[1, 2] : readonly [1, 2] ->1 : 1 ->2 : 2 - - b: new Set(["a", "b"]), ->b : Set ->new Set(["a", "b"]) : Set ->Set : SetConstructor ->["a", "b"] : string[] ->"a" : "a" ->"b" : "b" - - [key]: [true, false], ->[key] : readonly [true, false] ->key : unique symbol ->[true, false] : readonly [true, false] ->true : true ->false : false - -} as const).toArray(); ->toArray : () => { a: 1 | 2; b: string; [key]: boolean; }[] - -objects[0].a = 2; ->objects[0].a = 2 : 2 ->objects[0].a : number ->objects[0] : { a: number; b: string; [key]: boolean; } ->objects : { a: number; b: string; [key]: boolean; }[] ->0 : 0 ->a : number ->2 : 2 - -const longestObjectsWithPadding: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { ->longestObjectsWithPadding : { a: number; b: string; }[] ->a : number ->b : string ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}).toArray() : { a: number; b: string; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}).toArray : () => { a: number; b: string; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}) : IteratorObject<{ a: number; b: string; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } ->{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } ->a : readonly [1] ->[1] : readonly [1] ->1 : 1 ->b : readonly ["a"] ->["a"] : readonly ["a"] ->"a" : "a" ->{ mode: "longest", padding: { a: 1, b: "a" },} : { mode: "longest"; padding: { a: 1; b: "a"; }; } - - mode: "longest", ->mode : "longest" ->"longest" : "longest" - - padding: { a: 1, b: "a" }, ->padding : { a: 1; b: "a"; } ->{ a: 1, b: "a" } : { a: 1; b: "a"; } ->a : 1 ->1 : 1 ->b : "a" ->"a" : "a" - -}).toArray(); ->toArray : () => { a: number; b: string; }[] - -const longestObjectsWithoutPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { ->longestObjectsWithoutPadding : { a: number | undefined; b: string | undefined; }[] ->a : number | undefined ->b : string | undefined ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}).toArray() : { a: 1 | undefined; b: "a" | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}).toArray : () => { a: 1 | undefined; b: "a" | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}) : IteratorObject<{ a: 1 | undefined; b: "a" | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } ->{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } ->a : readonly [1] ->[1] : readonly [1] ->1 : 1 ->b : readonly ["a"] ->["a"] : readonly ["a"] ->"a" : "a" ->{ mode: "longest",} : { mode: "longest"; } - - mode: "longest", ->mode : "longest" ->"longest" : "longest" - -}).toArray(); ->toArray : () => { a: 1 | undefined; b: "a" | undefined; }[] - -const longestObjectsWithPartialPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { ->longestObjectsWithPartialPadding : { a: number | undefined; b: string | undefined; }[] ->a : number | undefined ->b : string | undefined ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}).toArray() : { a: 1 | undefined; b: string; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}).toArray : () => { a: 1 | undefined; b: string; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}) : IteratorObject<{ a: 1 | undefined; b: string; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } ->{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } ->a : readonly [1] ->[1] : readonly [1] ->1 : 1 ->b : readonly ["a"] ->["a"] : readonly ["a"] ->"a" : "a" ->{ mode: "longest", padding: { b: "a" },} : { mode: "longest"; padding: { b: "a"; }; } - - mode: "longest", ->mode : "longest" ->"longest" : "longest" - - padding: { b: "a" }, ->padding : { b: "a"; } ->{ b: "a" } : { b: "a"; } ->b : "a" ->"a" : "a" - -}).toArray(); ->toArray : () => { a: 1 | undefined; b: string; }[] - -const maybeLongestObjects: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray(); ->maybeLongestObjects : { a: number | undefined; b: string | undefined; }[] ->a : number | undefined ->b : string | undefined ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray() : { a: 1 | undefined; b: "a" | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray : () => { a: 1 | undefined; b: "a" | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions) : IteratorObject<{ a: 1 | undefined; b: "a" | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } ->{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } ->a : readonly [1] ->[1] : readonly [1] ->1 : 1 ->b : readonly ["a"] ->["a"] : readonly ["a"] ->"a" : "a" ->maybeLongestOptions : { mode: "shortest"; } | { mode: "longest"; } ->toArray : () => { a: 1 | undefined; b: "a" | undefined; }[] - -interface Inputs { - a: Iterable; ->a : Iterable - - b: Iterator; ->b : Iterator -} - -declare const inputs: Inputs; ->inputs : Inputs - -const rows: { a: number; b: string; }[] = Iterator.zipKeyed(inputs).toArray(); ->rows : { a: number; b: string; }[] ->a : number ->b : string ->Iterator.zipKeyed(inputs).toArray() : { a: number; b: string; }[] ->Iterator.zipKeyed(inputs).toArray : () => { a: number; b: string; }[] ->Iterator.zipKeyed(inputs) : IteratorObject<{ a: number; b: string; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->inputs : Inputs ->toArray : () => { a: number; b: string; }[] - -Iterator.zip([[1]], { mode: "invalid" }); ->Iterator.zip([[1]], { mode: "invalid" }) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->[[1]] : [number[]] ->[1] : number[] ->1 : 1 ->{ mode: "invalid" } : { mode: "invalid"; } ->mode : "invalid" ->"invalid" : "invalid" - -Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }); ->Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->[[1], ["a"]] as const : readonly [readonly [1], readonly ["a"]] ->[[1], ["a"]] : readonly [readonly [1], readonly ["a"]] ->[1] : readonly [1] ->1 : 1 ->["a"] : readonly ["a"] ->"a" : "a" ->{ mode: "longest", padding: [true] } : { mode: "longest"; padding: boolean[]; } ->mode : "longest" ->"longest" : "longest" ->padding : boolean[] ->[true] : boolean[] ->true : true - -Iterator.zip([[1]], { mode: "shortest", padding: [1] }); ->Iterator.zip([[1]], { mode: "shortest", padding: [1] }) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->[[1]] : [number[]] ->[1] : number[] ->1 : 1 ->{ mode: "shortest", padding: [1] } : { mode: "shortest"; padding: number[]; } ->mode : "shortest" ->"shortest" : "shortest" ->padding : number[] ->[1] : number[] ->1 : 1 - -Iterator.zip(0); ->Iterator.zip(0) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->0 : 0 - -Iterator.zipKeyed({ a: 0 }); ->Iterator.zipKeyed({ a: 0 }) : IteratorObject<{ a: never; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ a: 0 } : { a: number; } ->a : number ->0 : 0 - -const emptyKeyed: never[] = Iterator.zipKeyed({}).toArray(); ->emptyKeyed : never[] ->Iterator.zipKeyed({}).toArray() : never[] ->Iterator.zipKeyed({}).toArray : () => never[] ->Iterator.zipKeyed({}) : IteratorObject ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{} : {} ->toArray : () => never[] - -const emptyKeyedLongest: never[] = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); ->emptyKeyedLongest : never[] ->Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray() : never[] ->Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray : () => never[] ->Iterator.zipKeyed({}, { mode: "longest", padding: {} }) : IteratorObject ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{} : {} ->{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } ->mode : "longest" ->"longest" : "longest" ->padding : {} ->{} : {} ->toArray : () => never[] - -declare const unionInputs: { a: Iterable; } | { b: Iterator; }; ->unionInputs : { a: Iterable; } | { b: Iterator; } ->a : Iterable ->b : Iterator - -const unionRows: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(unionInputs).toArray(); ->unionRows : ({ a: number; } | { b: string; })[] ->a : number ->b : string ->Iterator.zipKeyed(unionInputs).toArray() : ({ a: number; } | { b: string; })[] ->Iterator.zipKeyed(unionInputs).toArray : () => ({ a: number; } | { b: string; })[] ->Iterator.zipKeyed(unionInputs) : IteratorObject<{ a: number; } | { b: string; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->unionInputs : { a: Iterable; } | { b: Iterator; } ->toArray : () => ({ a: number; } | { b: string; })[] - diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=false).errors.txt b/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=false).errors.txt deleted file mode 100644 index 82cb9bbd4a0ca..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=false).errors.txt +++ /dev/null @@ -1,266 +0,0 @@ -iteratorZipInputs.ts(1,14): error TS2769: No overload matches this call. - The last overload gave the following error. - Argument of type 'string' is not assignable to parameter of type 'Iterable> & object'. - Type 'string' is not assignable to type 'Iterable>'. -iteratorZipInputs.ts(2,14): error TS2769: No overload matches this call. - The last overload gave the following error. - Argument of type 'string[]' is not assignable to parameter of type 'Iterable> & object'. - Type 'string[]' is not assignable to type 'Iterable>'. - The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. - Type 'IteratorResult' is not assignable to type 'IteratorResult, any>'. - Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>'. - Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>'. - Type 'string' is not assignable to type 'IteratorInput'. -iteratorZipInputs.ts(3,14): error TS2769: No overload matches this call. - The last overload gave the following error. - Argument of type 'Set' is not assignable to parameter of type 'Iterable> & object'. - Type 'Set' is not assignable to type 'Iterable>'. - The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. - Type 'IteratorResult' is not assignable to type 'IteratorResult, any>'. - Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>'. - Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>'. - Type 'string' is not assignable to type 'IteratorInput'. -iteratorZipInputs.ts(4,19): error TS2345: Argument of type 'string' is not assignable to parameter of type 'object & IteratorZipKeyedInput'. - Type 'string' is not assignable to type 'object'. -iteratorZipInputs.ts(5,21): error TS2322: Type 'string' is not assignable to type 'never'. -iteratorZipInputs.ts(6,37): error TS2769: No overload matches this call. - The last overload gave the following error. - Type 'string' is not assignable to type 'Iterable & object'. - Type 'string' is not assignable to type 'Iterable'. -iteratorZipInputs.ts(7,42): error TS2769: No overload matches this call. - The last overload gave the following error. - Type 'string' is not assignable to type 'Iterable & object'. - Type 'string' is not assignable to type 'object'. -iteratorZipInputs.ts(8,42): error TS2769: No overload matches this call. - The last overload gave the following error. - Type 'string' is not assignable to type 'object'. -iteratorZipInputs.ts(16,6): error TS2339: Property 'b' does not exist on type 'IteratorZipResult<{ a: number[]; } & {}, never, {}>'. -iteratorZipInputs.ts(32,6): error TS2339: Property 'd' does not exist on type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator | undefined; readonly c?: Iterable | undefined; }, never, {}>'. -iteratorZipInputs.ts(33,7): error TS2322: Type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator | undefined; readonly c?: Iterable | undefined; }, never, {}>[]' is not assignable to type '{ a: number; c: boolean; }[]'. - Type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator | undefined; readonly c?: Iterable | undefined; }, never, {}>' is not assignable to type '{ a: number; c: boolean; }'. - Types of property 'c' are incompatible. - Type 'boolean | undefined' is not assignable to type 'boolean'. - Type 'undefined' is not assignable to type 'boolean'. -iteratorZipInputs.ts(39,19): error TS2345: Argument of type '{ a: Iterable; } | { b: number; }' is not assignable to parameter of type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. - Type '{ b: number; }' is not assignable to type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. - Type '{ b: number; }' is not assignable to type '{ b: number; } & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. - Type '{ b: number; }' is not assignable to type 'IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. - Types of property 'b' are incompatible. - Type 'number' is not assignable to type 'IteratorInput | undefined'. -iteratorZipInputs.ts(40,19): error TS2769: No overload matches this call. - The last overload gave the following error. - Argument of type '{ a: Iterable; } | { b: number; }' is not assignable to parameter of type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. - Type '{ b: number; }' is not assignable to type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. - Type '{ b: number; }' is not assignable to type '{ b: number; } & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. - Type '{ b: number; }' is not assignable to type 'IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. - Types of property 'b' are incompatible. - Type 'number' is not assignable to type 'IteratorInput | undefined'. -iteratorZipInputs.ts(41,19): error TS2769: No overload matches this call. - The last overload gave the following error. - Argument of type '{ a: Iterable; } | { b: number; }' is not assignable to parameter of type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. - Type '{ b: number; }' is not assignable to type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. - Type '{ b: number; }' is not assignable to type '{ b: number; } & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. - Type '{ b: number; }' is not assignable to type 'IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. - Types of property 'b' are incompatible. - Type 'number' is not assignable to type 'IteratorInput | undefined'. -iteratorZipInputs.ts(43,19): error TS2345: Argument of type '{ a?: Iterable | undefined; } | { b: string; }' is not assignable to parameter of type '({ a?: Iterable | undefined; } | { b: string; }) & IteratorZipKeyedInput<{ a?: Iterable | undefined; } | { b: string; }>'. - Type '{ b: string; }' is not assignable to type '({ a?: Iterable | undefined; } | { b: string; }) & IteratorZipKeyedInput<{ a?: Iterable | undefined; } | { b: string; }>'. - Type '{ b: string; }' is not assignable to type '{ b: string; } & IteratorZipKeyedInput<{ a?: Iterable | undefined; } | { b: string; }>'. - Type '{ b: string; }' is not assignable to type 'IteratorZipKeyedInput<{ a?: Iterable | undefined; } | { b: string; }>'. - Types of property 'b' are incompatible. - Type 'string' is not assignable to type 'IteratorInput | undefined'. -iteratorZipInputs.ts(51,21): error TS2322: Type 'number[]' is not assignable to type 'never'. -iteratorZipInputs.ts(51,29): error TS2322: Type 'null' is not assignable to type 'never'. -iteratorZipInputs.ts(52,21): error TS2322: Type 'number[]' is not assignable to type 'never'. -iteratorZipInputs.ts(52,29): error TS2322: Type 'false' is not assignable to type 'never'. -iteratorZipInputs.ts(53,14): error TS2769: No overload matches this call. - The last overload gave the following error. - Argument of type 'undefined[]' is not assignable to parameter of type 'Iterable> & object'. - Type 'undefined[]' is not assignable to type 'Iterable>'. - The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. - Type 'IteratorResult' is not assignable to type 'IteratorResult, any>'. - Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>'. - Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>'. - Type 'undefined' is not assignable to type 'IteratorInput'. - - -==== iteratorZipInputs.ts (20 errors) ==== - Iterator.zip("ab"); - ~~~~ -!!! error TS2769: No overload matches this call. -!!! error TS2769: The last overload gave the following error. -!!! error TS2769: Argument of type 'string' is not assignable to parameter of type 'Iterable> & object'. -!!! error TS2769: Type 'string' is not assignable to type 'Iterable>'. -!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. - Iterator.zip(["ab"]); - ~~~~~~ -!!! error TS2769: No overload matches this call. -!!! error TS2769: The last overload gave the following error. -!!! error TS2769: Argument of type 'string[]' is not assignable to parameter of type 'Iterable> & object'. -!!! error TS2769: Type 'string[]' is not assignable to type 'Iterable>'. -!!! error TS2769: The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. -!!! error TS2769: Type 'IteratorResult' is not assignable to type 'IteratorResult, any>'. -!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>'. -!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>'. -!!! error TS2769: Type 'string' is not assignable to type 'IteratorInput'. -!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. - Iterator.zip(new Set(["ab"])); - ~~~~~~~~~~~~~~~ -!!! error TS2769: No overload matches this call. -!!! error TS2769: The last overload gave the following error. -!!! error TS2769: Argument of type 'Set' is not assignable to parameter of type 'Iterable> & object'. -!!! error TS2769: Type 'Set' is not assignable to type 'Iterable>'. -!!! error TS2769: The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. -!!! error TS2769: Type 'IteratorResult' is not assignable to type 'IteratorResult, any>'. -!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>'. -!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>'. -!!! error TS2769: Type 'string' is not assignable to type 'IteratorInput'. -!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. - Iterator.zipKeyed("ab"); - ~~~~ -!!! error TS2345: Argument of type 'string' is not assignable to parameter of type 'object & IteratorZipKeyedInput'. -!!! error TS2345: Type 'string' is not assignable to type 'object'. - Iterator.zipKeyed({ a: "ab" }); - ~ -!!! error TS2322: Type 'string' is not assignable to type 'never'. -!!! related TS6500 iteratorZipInputs.ts:5:21: The expected type comes from property 'a' which is declared here on type '{ a: string; } & IteratorZipKeyedInput<{ a: string; }>' - Iterator.zip([], { mode: "longest", padding: "ab" }); - ~~~~~~~ -!!! error TS2769: No overload matches this call. -!!! error TS2769: The last overload gave the following error. -!!! error TS2769: Type 'string' is not assignable to type 'Iterable & object'. -!!! error TS2769: Type 'string' is not assignable to type 'Iterable'. -!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. - Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); - ~~~~~~~ -!!! error TS2769: No overload matches this call. -!!! error TS2769: The last overload gave the following error. -!!! error TS2769: Type 'string' is not assignable to type 'Iterable & object'. -!!! error TS2769: Type 'string' is not assignable to type 'object'. -!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. - Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); - ~~~~~~~ -!!! error TS2769: No overload matches this call. -!!! error TS2769: The last overload gave the following error. -!!! error TS2769: Type 'string' is not assignable to type 'object'. -!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. - - const a: [string][] = Iterator.zip([new String("ab")]).toArray(); - const b: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); - const c: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); - - const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); - const e: { a: number; }[] = d; - d[0].b; - ~ -!!! error TS2339: Property 'b' does not exist on type 'IteratorZipResult<{ a: number[]; } & {}, never, {}>'. - const f: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); - const g: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); - - interface I { - readonly a: Iterable; - readonly b?: Iterator; - readonly c: Iterable | undefined; - readonly d?: undefined; - } - declare const h: I; - const i = Iterator.zipKeyed(h).toArray(); - const j: { a: number; b?: string; c?: boolean; }[] = i; - i[0].a = 2; - i[0].b = "a"; - i[0].c = true; - i[0].d; - ~ -!!! error TS2339: Property 'd' does not exist on type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator | undefined; readonly c?: Iterable | undefined; }, never, {}>'. - const k: { a: number; c: boolean; }[] = i; - ~ -!!! error TS2322: Type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator | undefined; readonly c?: Iterable | undefined; }, never, {}>[]' is not assignable to type '{ a: number; c: boolean; }[]'. -!!! error TS2322: Type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator | undefined; readonly c?: Iterable | undefined; }, never, {}>' is not assignable to type '{ a: number; c: boolean; }'. -!!! error TS2322: Types of property 'c' are incompatible. -!!! error TS2322: Type 'boolean | undefined' is not assignable to type 'boolean'. -!!! error TS2322: Type 'undefined' is not assignable to type 'boolean'. - const l: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); - - declare const m: { a: Iterable; } | { b: Iterator; }; - const n: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(m).toArray(); - declare const o: { a: Iterable; } | { b: number; }; - Iterator.zipKeyed(o); - ~ -!!! error TS2345: Argument of type '{ a: Iterable; } | { b: number; }' is not assignable to parameter of type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. -!!! error TS2345: Type '{ b: number; }' is not assignable to type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. -!!! error TS2345: Type '{ b: number; }' is not assignable to type '{ b: number; } & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. -!!! error TS2345: Type '{ b: number; }' is not assignable to type 'IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. -!!! error TS2345: Types of property 'b' are incompatible. -!!! error TS2345: Type 'number' is not assignable to type 'IteratorInput | undefined'. - Iterator.zipKeyed(o, { mode: "longest" }); - ~ -!!! error TS2769: No overload matches this call. -!!! error TS2769: The last overload gave the following error. -!!! error TS2769: Argument of type '{ a: Iterable; } | { b: number; }' is not assignable to parameter of type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. -!!! error TS2769: Type '{ b: number; }' is not assignable to type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. -!!! error TS2769: Type '{ b: number; }' is not assignable to type '{ b: number; } & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. -!!! error TS2769: Type '{ b: number; }' is not assignable to type 'IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. -!!! error TS2769: Types of property 'b' are incompatible. -!!! error TS2769: Type 'number' is not assignable to type 'IteratorInput | undefined'. -!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. - Iterator.zipKeyed(o, { mode: "longest", padding: {} }); - ~ -!!! error TS2769: No overload matches this call. -!!! error TS2769: The last overload gave the following error. -!!! error TS2769: Argument of type '{ a: Iterable; } | { b: number; }' is not assignable to parameter of type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. -!!! error TS2769: Type '{ b: number; }' is not assignable to type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. -!!! error TS2769: Type '{ b: number; }' is not assignable to type '{ b: number; } & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. -!!! error TS2769: Type '{ b: number; }' is not assignable to type 'IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. -!!! error TS2769: Types of property 'b' are incompatible. -!!! error TS2769: Type 'number' is not assignable to type 'IteratorInput | undefined'. -!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. - declare const p: { a?: Iterable; } | { b: string; }; - Iterator.zipKeyed(p); - ~ -!!! error TS2345: Argument of type '{ a?: Iterable | undefined; } | { b: string; }' is not assignable to parameter of type '({ a?: Iterable | undefined; } | { b: string; }) & IteratorZipKeyedInput<{ a?: Iterable | undefined; } | { b: string; }>'. -!!! error TS2345: Type '{ b: string; }' is not assignable to type '({ a?: Iterable | undefined; } | { b: string; }) & IteratorZipKeyedInput<{ a?: Iterable | undefined; } | { b: string; }>'. -!!! error TS2345: Type '{ b: string; }' is not assignable to type '{ b: string; } & IteratorZipKeyedInput<{ a?: Iterable | undefined; } | { b: string; }>'. -!!! error TS2345: Type '{ b: string; }' is not assignable to type 'IteratorZipKeyedInput<{ a?: Iterable | undefined; } | { b: string; }>'. -!!! error TS2345: Types of property 'b' are incompatible. -!!! error TS2345: Type 'string' is not assignable to type 'IteratorInput | undefined'. - declare const q: { a: Iterable; } | { b: undefined; }; - const r: { a: number; }[] = Iterator.zipKeyed(q).toArray(); - - declare const s: unique symbol; - declare const t: { a: Iterable; [s]?: Iterable; }; - const u: { a: number; [s]?: string; }[] = Iterator.zipKeyed(t).toArray(); - - Iterator.zipKeyed({ a: [1], b: null }); - ~ -!!! error TS2322: Type 'number[]' is not assignable to type 'never'. - ~ -!!! error TS2322: Type 'null' is not assignable to type 'never'. - Iterator.zipKeyed({ a: [1], b: false }); - ~ -!!! error TS2322: Type 'number[]' is not assignable to type 'never'. - ~ -!!! error TS2322: Type 'false' is not assignable to type 'never'. - Iterator.zip([undefined]); - ~~~~~~~~~~~ -!!! error TS2769: No overload matches this call. -!!! error TS2769: The last overload gave the following error. -!!! error TS2769: Argument of type 'undefined[]' is not assignable to parameter of type 'Iterable> & object'. -!!! error TS2769: Type 'undefined[]' is not assignable to type 'Iterable>'. -!!! error TS2769: The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. -!!! error TS2769: Type 'IteratorResult' is not assignable to type 'IteratorResult, any>'. -!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>'. -!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>'. -!!! error TS2769: Type 'undefined' is not assignable to type 'IteratorInput'. -!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. - - declare const v: { a?: undefined; }; - const w: never[] = Iterator.zipKeyed(v).toArray(); - const x: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); - const y: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); - - function f1(a: Iterable) { - const b: { a: T; }[] = Iterator.zipKeyed({ a }).toArray(); - const c: [T][] = Iterator.zip([a]).toArray(); - return { b, c }; - } - \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=false).js b/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=false).js deleted file mode 100644 index 565466b55ab2d..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=false).js +++ /dev/null @@ -1,208 +0,0 @@ -//// [tests/cases/compiler/iteratorZipInputs.ts] //// - -//// [iteratorZipInputs.ts] -Iterator.zip("ab"); -Iterator.zip(["ab"]); -Iterator.zip(new Set(["ab"])); -Iterator.zipKeyed("ab"); -Iterator.zipKeyed({ a: "ab" }); -Iterator.zip([], { mode: "longest", padding: "ab" }); -Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); -Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); - -const a: [string][] = Iterator.zip([new String("ab")]).toArray(); -const b: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); -const c: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); - -const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); -const e: { a: number; }[] = d; -d[0].b; -const f: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); -const g: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); - -interface I { - readonly a: Iterable; - readonly b?: Iterator; - readonly c: Iterable | undefined; - readonly d?: undefined; -} -declare const h: I; -const i = Iterator.zipKeyed(h).toArray(); -const j: { a: number; b?: string; c?: boolean; }[] = i; -i[0].a = 2; -i[0].b = "a"; -i[0].c = true; -i[0].d; -const k: { a: number; c: boolean; }[] = i; -const l: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); - -declare const m: { a: Iterable; } | { b: Iterator; }; -const n: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(m).toArray(); -declare const o: { a: Iterable; } | { b: number; }; -Iterator.zipKeyed(o); -Iterator.zipKeyed(o, { mode: "longest" }); -Iterator.zipKeyed(o, { mode: "longest", padding: {} }); -declare const p: { a?: Iterable; } | { b: string; }; -Iterator.zipKeyed(p); -declare const q: { a: Iterable; } | { b: undefined; }; -const r: { a: number; }[] = Iterator.zipKeyed(q).toArray(); - -declare const s: unique symbol; -declare const t: { a: Iterable; [s]?: Iterable; }; -const u: { a: number; [s]?: string; }[] = Iterator.zipKeyed(t).toArray(); - -Iterator.zipKeyed({ a: [1], b: null }); -Iterator.zipKeyed({ a: [1], b: false }); -Iterator.zip([undefined]); - -declare const v: { a?: undefined; }; -const w: never[] = Iterator.zipKeyed(v).toArray(); -const x: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); -const y: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); - -function f1(a: Iterable) { - const b: { a: T; }[] = Iterator.zipKeyed({ a }).toArray(); - const c: [T][] = Iterator.zip([a]).toArray(); - return { b, c }; -} - - -//// [iteratorZipInputs.js] -"use strict"; -Iterator.zip("ab"); -Iterator.zip(["ab"]); -Iterator.zip(new Set(["ab"])); -Iterator.zipKeyed("ab"); -Iterator.zipKeyed({ a: "ab" }); -Iterator.zip([], { mode: "longest", padding: "ab" }); -Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); -Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); -const a = Iterator.zip([new String("ab")]).toArray(); -const b = Iterator.zipKeyed({ a: new String("ab") }).toArray(); -const c = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); -const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); -const e = d; -d[0].b; -const f = Iterator.zipKeyed({ a: undefined }).toArray(); -const g = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); -const i = Iterator.zipKeyed(h).toArray(); -const j = i; -i[0].a = 2; -i[0].b = "a"; -i[0].c = true; -i[0].d; -const k = i; -const l = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); -const n = Iterator.zipKeyed(m).toArray(); -Iterator.zipKeyed(o); -Iterator.zipKeyed(o, { mode: "longest" }); -Iterator.zipKeyed(o, { mode: "longest", padding: {} }); -Iterator.zipKeyed(p); -const r = Iterator.zipKeyed(q).toArray(); -const u = Iterator.zipKeyed(t).toArray(); -Iterator.zipKeyed({ a: [1], b: null }); -Iterator.zipKeyed({ a: [1], b: false }); -Iterator.zip([undefined]); -const w = Iterator.zipKeyed(v).toArray(); -const x = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); -const y = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); -function f1(a) { - const b = Iterator.zipKeyed({ a }).toArray(); - const c = Iterator.zip([a]).toArray(); - return { b, c }; -} - - -//// [iteratorZipInputs.d.ts] -declare const a: [string][]; -declare const b: { - a: string; -}[]; -declare const c: (string | undefined)[][]; -declare const d: { - a: number; -}[]; -declare const e: { - a: number; -}[]; -declare const f: never[]; -declare const g: never[]; -interface I { - readonly a: Iterable; - readonly b?: Iterator; - readonly c: Iterable | undefined; - readonly d?: undefined; -} -declare const h: I; -declare const i: { - a: number; - b?: string | undefined; - c?: boolean | undefined; -}[]; -declare const j: { - a: number; - b?: string; - c?: boolean; -}[]; -declare const k: { - a: number; - c: boolean; -}[]; -declare const l: { - a: number | undefined; - b?: string | undefined; - c?: boolean | undefined; -}[]; -declare const m: { - a: Iterable; -} | { - b: Iterator; -}; -declare const n: ({ - a: number; -} | { - b: string; -})[]; -declare const o: { - a: Iterable; -} | { - b: number; -}; -declare const p: { - a?: Iterable; -} | { - b: string; -}; -declare const q: { - a: Iterable; -} | { - b: undefined; -}; -declare const r: { - a: number; -}[]; -declare const s: unique symbol; -declare const t: { - a: Iterable; - [s]?: Iterable; -}; -declare const u: { - a: number; - [s]?: string; -}[]; -declare const v: { - a?: undefined; -}; -declare const w: never[]; -declare const x: { - a: number; -}[]; -declare const y: { - a: number | undefined; -}[]; -declare function f1(a: Iterable): { - b: { - a: T; - }[]; - c: [T][]; -}; diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=false).symbols b/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=false).symbols deleted file mode 100644 index b9e998282517a..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=false).symbols +++ /dev/null @@ -1,388 +0,0 @@ -//// [tests/cases/compiler/iteratorZipInputs.ts] //// - -=== iteratorZipInputs.ts === -Iterator.zip("ab"); ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) - -Iterator.zip(["ab"]); ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) - -Iterator.zip(new Set(["ab"])); ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Set : Symbol(Set, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) - -Iterator.zipKeyed("ab"); ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) - -Iterator.zipKeyed({ a: "ab" }); ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 4, 19)) - -Iterator.zip([], { mode: "longest", padding: "ab" }); ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZipInputs.ts, 5, 18)) ->padding : Symbol(padding, Decl(iteratorZipInputs.ts, 5, 35)) - -Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZipInputs.ts, 6, 23)) ->padding : Symbol(padding, Decl(iteratorZipInputs.ts, 6, 40)) - -Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->mode : Symbol(mode, Decl(iteratorZipInputs.ts, 7, 23)) ->padding : Symbol(padding, Decl(iteratorZipInputs.ts, 7, 40)) - -const a: [string][] = Iterator.zip([new String("ab")]).toArray(); ->a : Symbol(a, Decl(iteratorZipInputs.ts, 9, 5)) ->Iterator.zip([new String("ab")]).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const b: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); ->b : Symbol(b, Decl(iteratorZipInputs.ts, 10, 5)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 10, 10)) ->Iterator.zipKeyed({ a: new String("ab") }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 10, 47)) ->String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const c: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); ->c : Symbol(c, Decl(iteratorZipInputs.ts, 11, 5)) ->Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZipInputs.ts, 11, 59)) ->padding : Symbol(padding, Decl(iteratorZipInputs.ts, 11, 76)) ->String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); ->d : Symbol(d, Decl(iteratorZipInputs.ts, 13, 5)) ->Iterator.zipKeyed({ a: [1], b: undefined }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 13, 29)) ->b : Symbol(b, Decl(iteratorZipInputs.ts, 13, 37)) ->undefined : Symbol(undefined) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const e: { a: number; }[] = d; ->e : Symbol(e, Decl(iteratorZipInputs.ts, 14, 5)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 14, 10)) ->d : Symbol(d, Decl(iteratorZipInputs.ts, 13, 5)) - -d[0].b; ->d : Symbol(d, Decl(iteratorZipInputs.ts, 13, 5)) - -const f: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); ->f : Symbol(f, Decl(iteratorZipInputs.ts, 16, 5)) ->Iterator.zipKeyed({ a: undefined }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 16, 38)) ->undefined : Symbol(undefined) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const g: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); ->g : Symbol(g, Decl(iteratorZipInputs.ts, 17, 5)) ->Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 17, 38)) ->undefined : Symbol(undefined) ->mode : Symbol(mode, Decl(iteratorZipInputs.ts, 17, 56)) ->padding : Symbol(padding, Decl(iteratorZipInputs.ts, 17, 73)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -interface I { ->I : Symbol(I, Decl(iteratorZipInputs.ts, 17, 99)) - - readonly a: Iterable; ->a : Symbol(I.a, Decl(iteratorZipInputs.ts, 19, 13)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) - - readonly b?: Iterator; ->b : Symbol(I.b, Decl(iteratorZipInputs.ts, 20, 33)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) - - readonly c: Iterable | undefined; ->c : Symbol(I.c, Decl(iteratorZipInputs.ts, 21, 34)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) - - readonly d?: undefined; ->d : Symbol(I.d, Decl(iteratorZipInputs.ts, 22, 46)) -} -declare const h: I; ->h : Symbol(h, Decl(iteratorZipInputs.ts, 25, 13)) ->I : Symbol(I, Decl(iteratorZipInputs.ts, 17, 99)) - -const i = Iterator.zipKeyed(h).toArray(); ->i : Symbol(i, Decl(iteratorZipInputs.ts, 26, 5)) ->Iterator.zipKeyed(h).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->h : Symbol(h, Decl(iteratorZipInputs.ts, 25, 13)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const j: { a: number; b?: string; c?: boolean; }[] = i; ->j : Symbol(j, Decl(iteratorZipInputs.ts, 27, 5)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 27, 10)) ->b : Symbol(b, Decl(iteratorZipInputs.ts, 27, 21)) ->c : Symbol(c, Decl(iteratorZipInputs.ts, 27, 33)) ->i : Symbol(i, Decl(iteratorZipInputs.ts, 26, 5)) - -i[0].a = 2; ->i[0].a : Symbol(a, Decl(iteratorZipInputs.ts, 19, 13)) ->i : Symbol(i, Decl(iteratorZipInputs.ts, 26, 5)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 19, 13)) - -i[0].b = "a"; ->i[0].b : Symbol(b, Decl(iteratorZipInputs.ts, 20, 33)) ->i : Symbol(i, Decl(iteratorZipInputs.ts, 26, 5)) ->b : Symbol(b, Decl(iteratorZipInputs.ts, 20, 33)) - -i[0].c = true; ->i[0].c : Symbol(c, Decl(iteratorZipInputs.ts, 21, 34)) ->i : Symbol(i, Decl(iteratorZipInputs.ts, 26, 5)) ->c : Symbol(c, Decl(iteratorZipInputs.ts, 21, 34)) - -i[0].d; ->i : Symbol(i, Decl(iteratorZipInputs.ts, 26, 5)) - -const k: { a: number; c: boolean; }[] = i; ->k : Symbol(k, Decl(iteratorZipInputs.ts, 32, 5)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 32, 10)) ->c : Symbol(c, Decl(iteratorZipInputs.ts, 32, 21)) ->i : Symbol(i, Decl(iteratorZipInputs.ts, 26, 5)) - -const l: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); ->l : Symbol(l, Decl(iteratorZipInputs.ts, 33, 5)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 33, 10)) ->b : Symbol(b, Decl(iteratorZipInputs.ts, 33, 33)) ->c : Symbol(c, Decl(iteratorZipInputs.ts, 33, 57)) ->Iterator.zipKeyed(h, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->h : Symbol(h, Decl(iteratorZipInputs.ts, 25, 13)) ->mode : Symbol(mode, Decl(iteratorZipInputs.ts, 33, 111)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -declare const m: { a: Iterable; } | { b: Iterator; }; ->m : Symbol(m, Decl(iteratorZipInputs.ts, 35, 13)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 35, 18)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->b : Symbol(b, Decl(iteratorZipInputs.ts, 35, 45)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) - -const n: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(m).toArray(); ->n : Symbol(n, Decl(iteratorZipInputs.ts, 36, 5)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 36, 11)) ->b : Symbol(b, Decl(iteratorZipInputs.ts, 36, 28)) ->Iterator.zipKeyed(m).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->m : Symbol(m, Decl(iteratorZipInputs.ts, 35, 13)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -declare const o: { a: Iterable; } | { b: number; }; ->o : Symbol(o, Decl(iteratorZipInputs.ts, 37, 13)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 37, 18)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->b : Symbol(b, Decl(iteratorZipInputs.ts, 37, 45)) - -Iterator.zipKeyed(o); ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->o : Symbol(o, Decl(iteratorZipInputs.ts, 37, 13)) - -Iterator.zipKeyed(o, { mode: "longest" }); ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->o : Symbol(o, Decl(iteratorZipInputs.ts, 37, 13)) ->mode : Symbol(mode, Decl(iteratorZipInputs.ts, 39, 22)) - -Iterator.zipKeyed(o, { mode: "longest", padding: {} }); ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->o : Symbol(o, Decl(iteratorZipInputs.ts, 37, 13)) ->mode : Symbol(mode, Decl(iteratorZipInputs.ts, 40, 22)) ->padding : Symbol(padding, Decl(iteratorZipInputs.ts, 40, 39)) - -declare const p: { a?: Iterable; } | { b: string; }; ->p : Symbol(p, Decl(iteratorZipInputs.ts, 41, 13)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 41, 18)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->b : Symbol(b, Decl(iteratorZipInputs.ts, 41, 46)) - -Iterator.zipKeyed(p); ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->p : Symbol(p, Decl(iteratorZipInputs.ts, 41, 13)) - -declare const q: { a: Iterable; } | { b: undefined; }; ->q : Symbol(q, Decl(iteratorZipInputs.ts, 43, 13)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 43, 18)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->b : Symbol(b, Decl(iteratorZipInputs.ts, 43, 45)) - -const r: { a: number; }[] = Iterator.zipKeyed(q).toArray(); ->r : Symbol(r, Decl(iteratorZipInputs.ts, 44, 5)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 44, 10)) ->Iterator.zipKeyed(q).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->q : Symbol(q, Decl(iteratorZipInputs.ts, 43, 13)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -declare const s: unique symbol; ->s : Symbol(s, Decl(iteratorZipInputs.ts, 46, 13)) - -declare const t: { a: Iterable; [s]?: Iterable; }; ->t : Symbol(t, Decl(iteratorZipInputs.ts, 47, 13)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 47, 18)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->[s] : Symbol([s], Decl(iteratorZipInputs.ts, 47, 39)) ->s : Symbol(s, Decl(iteratorZipInputs.ts, 46, 13)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) - -const u: { a: number; [s]?: string; }[] = Iterator.zipKeyed(t).toArray(); ->u : Symbol(u, Decl(iteratorZipInputs.ts, 48, 5)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 48, 10)) ->[s] : Symbol([s], Decl(iteratorZipInputs.ts, 48, 21)) ->s : Symbol(s, Decl(iteratorZipInputs.ts, 46, 13)) ->Iterator.zipKeyed(t).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->t : Symbol(t, Decl(iteratorZipInputs.ts, 47, 13)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -Iterator.zipKeyed({ a: [1], b: null }); ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 50, 19)) ->b : Symbol(b, Decl(iteratorZipInputs.ts, 50, 27)) - -Iterator.zipKeyed({ a: [1], b: false }); ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 51, 19)) ->b : Symbol(b, Decl(iteratorZipInputs.ts, 51, 27)) - -Iterator.zip([undefined]); ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->undefined : Symbol(undefined) - -declare const v: { a?: undefined; }; ->v : Symbol(v, Decl(iteratorZipInputs.ts, 54, 13)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 54, 18)) - -const w: never[] = Iterator.zipKeyed(v).toArray(); ->w : Symbol(w, Decl(iteratorZipInputs.ts, 55, 5)) ->Iterator.zipKeyed(v).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->v : Symbol(v, Decl(iteratorZipInputs.ts, 54, 13)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const x: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); ->x : Symbol(x, Decl(iteratorZipInputs.ts, 56, 5)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 56, 10)) ->Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 56, 47)) ->b : Symbol(b, Decl(iteratorZipInputs.ts, 56, 55)) ->undefined : Symbol(undefined) ->mode : Symbol(mode, Decl(iteratorZipInputs.ts, 56, 73)) ->padding : Symbol(padding, Decl(iteratorZipInputs.ts, 56, 90)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 56, 101)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const y: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); ->y : Symbol(y, Decl(iteratorZipInputs.ts, 57, 5)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 57, 10)) ->Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 57, 59)) ->b : Symbol(b, Decl(iteratorZipInputs.ts, 57, 67)) ->undefined : Symbol(undefined) ->mode : Symbol(mode, Decl(iteratorZipInputs.ts, 57, 85)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -function f1(a: Iterable) { ->f1 : Symbol(f1, Decl(iteratorZipInputs.ts, 57, 115)) ->T : Symbol(T, Decl(iteratorZipInputs.ts, 59, 12)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 59, 15)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->T : Symbol(T, Decl(iteratorZipInputs.ts, 59, 12)) - - const b: { a: T; }[] = Iterator.zipKeyed({ a }).toArray(); ->b : Symbol(b, Decl(iteratorZipInputs.ts, 60, 9)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 60, 14)) ->T : Symbol(T, Decl(iteratorZipInputs.ts, 59, 12)) ->Iterator.zipKeyed({ a }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 60, 46)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - - const c: [T][] = Iterator.zip([a]).toArray(); ->c : Symbol(c, Decl(iteratorZipInputs.ts, 61, 9)) ->T : Symbol(T, Decl(iteratorZipInputs.ts, 59, 12)) ->Iterator.zip([a]).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 59, 15)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - - return { b, c }; ->b : Symbol(b, Decl(iteratorZipInputs.ts, 62, 12)) ->c : Symbol(c, Decl(iteratorZipInputs.ts, 62, 15)) -} - diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=false).types b/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=false).types deleted file mode 100644 index 0506f0c4acbf8..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=false).types +++ /dev/null @@ -1,511 +0,0 @@ -//// [tests/cases/compiler/iteratorZipInputs.ts] //// - -=== iteratorZipInputs.ts === -Iterator.zip("ab"); ->Iterator.zip("ab") : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->"ab" : "ab" - -Iterator.zip(["ab"]); ->Iterator.zip(["ab"]) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->["ab"] : [string] ->"ab" : "ab" - -Iterator.zip(new Set(["ab"])); ->Iterator.zip(new Set(["ab"])) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->new Set(["ab"]) : Set ->Set : SetConstructor ->["ab"] : string[] ->"ab" : "ab" - -Iterator.zipKeyed("ab"); ->Iterator.zipKeyed("ab") : IteratorObject ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->"ab" : "ab" - -Iterator.zipKeyed({ a: "ab" }); ->Iterator.zipKeyed({ a: "ab" }) : IteratorObject<{ a: never; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ a: "ab" } : { a: string; } ->a : string ->"ab" : "ab" - -Iterator.zip([], { mode: "longest", padding: "ab" }); ->Iterator.zip([], { mode: "longest", padding: "ab" }) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->[] : [] ->{ mode: "longest", padding: "ab" } : { mode: "longest"; padding: string; } ->mode : "longest" ->"longest" : "longest" ->padding : string ->"ab" : "ab" - -Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); ->Iterator.zip([["a"]], { mode: "longest", padding: "ab" }) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->[["a"]] : [string[]] ->["a"] : string[] ->"a" : "a" ->{ mode: "longest", padding: "ab" } : { mode: "longest"; padding: string; } ->mode : "longest" ->"longest" : "longest" ->padding : string ->"ab" : "ab" - -Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); ->Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }) : IteratorObject ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{} : {} ->{ mode: "longest", padding: "ab" } : { mode: "longest"; padding: string; } ->mode : "longest" ->"longest" : "longest" ->padding : string ->"ab" : "ab" - -const a: [string][] = Iterator.zip([new String("ab")]).toArray(); ->a : [string][] ->Iterator.zip([new String("ab")]).toArray() : [string][] ->Iterator.zip([new String("ab")]).toArray : () => [string][] ->Iterator.zip([new String("ab")]) : IteratorObject<[string], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->[new String("ab")] : [String] ->new String("ab") : String ->String : StringConstructor ->"ab" : "ab" ->toArray : () => [string][] - -const b: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); ->b : { a: string; }[] ->a : string ->Iterator.zipKeyed({ a: new String("ab") }).toArray() : { a: string; }[] ->Iterator.zipKeyed({ a: new String("ab") }).toArray : () => { a: string; }[] ->Iterator.zipKeyed({ a: new String("ab") }) : IteratorObject<{ a: string; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ a: new String("ab") } : { a: String; } ->a : String ->new String("ab") : String ->String : StringConstructor ->"ab" : "ab" ->toArray : () => { a: string; }[] - -const c: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); ->c : (string | undefined)[][] ->Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray() : (string | undefined)[][] ->Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray : () => (string | undefined)[][] ->Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }) : IteratorObject<(string | undefined)[], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->[["a"]] : string[][] ->["a"] : string[] ->"a" : "a" ->{ mode: "longest", padding: new String("ab") } : { mode: "longest"; padding: String; } ->mode : "longest" ->"longest" : "longest" ->padding : String ->new String("ab") : String ->String : StringConstructor ->"ab" : "ab" ->toArray : () => (string | undefined)[][] - -const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); ->d : { a: number; }[] ->Iterator.zipKeyed({ a: [1], b: undefined }).toArray() : { a: number; }[] ->Iterator.zipKeyed({ a: [1], b: undefined }).toArray : () => { a: number; }[] ->Iterator.zipKeyed({ a: [1], b: undefined }) : IteratorObject<{ a: number; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ a: [1], b: undefined } : { a: number[]; b: undefined; } ->a : number[] ->[1] : number[] ->1 : 1 ->b : undefined ->undefined : undefined ->toArray : () => { a: number; }[] - -const e: { a: number; }[] = d; ->e : { a: number; }[] ->a : number ->d : { a: number; }[] - -d[0].b; ->d[0].b : any ->d[0] : { a: number; } ->d : { a: number; }[] ->0 : 0 ->b : any - -const f: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); ->f : never[] ->Iterator.zipKeyed({ a: undefined }).toArray() : never[] ->Iterator.zipKeyed({ a: undefined }).toArray : () => never[] ->Iterator.zipKeyed({ a: undefined }) : IteratorObject ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ a: undefined } : { a: undefined; } ->a : undefined ->undefined : undefined ->toArray : () => never[] - -const g: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); ->g : never[] ->Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray() : never[] ->Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray : () => never[] ->Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }) : IteratorObject ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ a: undefined } : { a: undefined; } ->a : undefined ->undefined : undefined ->{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } ->mode : "longest" ->"longest" : "longest" ->padding : {} ->{} : {} ->toArray : () => never[] - -interface I { - readonly a: Iterable; ->a : Iterable - - readonly b?: Iterator; ->b : Iterator | undefined - - readonly c: Iterable | undefined; ->c : Iterable | undefined - - readonly d?: undefined; ->d : undefined -} -declare const h: I; ->h : I - -const i = Iterator.zipKeyed(h).toArray(); ->i : { a: number; b?: string | undefined; c?: boolean | undefined; }[] ->Iterator.zipKeyed(h).toArray() : { a: number; b?: string | undefined; c?: boolean | undefined; }[] ->Iterator.zipKeyed(h).toArray : () => { a: number; b?: string | undefined; c?: boolean | undefined; }[] ->Iterator.zipKeyed(h) : IteratorObject<{ a: number; b?: string | undefined; c?: boolean | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->h : I ->toArray : () => { a: number; b?: string | undefined; c?: boolean | undefined; }[] - -const j: { a: number; b?: string; c?: boolean; }[] = i; ->j : { a: number; b?: string; c?: boolean; }[] ->a : number ->b : string | undefined ->c : boolean | undefined ->i : { a: number; b?: string | undefined; c?: boolean | undefined; }[] - -i[0].a = 2; ->i[0].a = 2 : 2 ->i[0].a : number ->i[0] : { a: number; b?: string | undefined; c?: boolean | undefined; } ->i : { a: number; b?: string | undefined; c?: boolean | undefined; }[] ->0 : 0 ->a : number ->2 : 2 - -i[0].b = "a"; ->i[0].b = "a" : "a" ->i[0].b : string | undefined ->i[0] : { a: number; b?: string | undefined; c?: boolean | undefined; } ->i : { a: number; b?: string | undefined; c?: boolean | undefined; }[] ->0 : 0 ->b : string | undefined ->"a" : "a" - -i[0].c = true; ->i[0].c = true : true ->i[0].c : boolean | undefined ->i[0] : { a: number; b?: string | undefined; c?: boolean | undefined; } ->i : { a: number; b?: string | undefined; c?: boolean | undefined; }[] ->0 : 0 ->c : boolean | undefined ->true : true - -i[0].d; ->i[0].d : any ->i[0] : { a: number; b?: string | undefined; c?: boolean | undefined; } ->i : { a: number; b?: string | undefined; c?: boolean | undefined; }[] ->0 : 0 ->d : any - -const k: { a: number; c: boolean; }[] = i; ->k : { a: number; c: boolean; }[] ->a : number ->c : boolean ->i : { a: number; b?: string | undefined; c?: boolean | undefined; }[] - -const l: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); ->l : { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] ->a : number | undefined ->b : string | undefined ->c : boolean | undefined ->Iterator.zipKeyed(h, { mode: "longest" }).toArray() : { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] ->Iterator.zipKeyed(h, { mode: "longest" }).toArray : () => { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] ->Iterator.zipKeyed(h, { mode: "longest" }) : IteratorObject<{ a: number | undefined; b?: string | undefined; c?: boolean | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->h : I ->{ mode: "longest" } : { mode: "longest"; } ->mode : "longest" ->"longest" : "longest" ->toArray : () => { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] - -declare const m: { a: Iterable; } | { b: Iterator; }; ->m : { a: Iterable; } | { b: Iterator; } ->a : Iterable ->b : Iterator - -const n: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(m).toArray(); ->n : ({ a: number; } | { b: string; })[] ->a : number ->b : string ->Iterator.zipKeyed(m).toArray() : ({ a: number; } | { b: string; })[] ->Iterator.zipKeyed(m).toArray : () => ({ a: number; } | { b: string; })[] ->Iterator.zipKeyed(m) : IteratorObject<{ a: number; } | { b: string; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->m : { a: Iterable; } | { b: Iterator; } ->toArray : () => ({ a: number; } | { b: string; })[] - -declare const o: { a: Iterable; } | { b: number; }; ->o : { a: Iterable; } | { b: number; } ->a : Iterable ->b : number - -Iterator.zipKeyed(o); ->Iterator.zipKeyed(o) : IteratorObject<{ a: number; } | { b: never; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->o : { a: Iterable; } | { b: number; } - -Iterator.zipKeyed(o, { mode: "longest" }); ->Iterator.zipKeyed(o, { mode: "longest" }) : IteratorObject<{ a: number; } | { b: never; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->o : { a: Iterable; } | { b: number; } ->{ mode: "longest" } : { mode: "longest"; } ->mode : "longest" ->"longest" : "longest" - -Iterator.zipKeyed(o, { mode: "longest", padding: {} }); ->Iterator.zipKeyed(o, { mode: "longest", padding: {} }) : IteratorObject<{ a: number; } | { b: never; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->o : { a: Iterable; } | { b: number; } ->{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } ->mode : "longest" ->"longest" : "longest" ->padding : {} ->{} : {} - -declare const p: { a?: Iterable; } | { b: string; }; ->p : { a?: Iterable; } | { b: string; } ->a : Iterable | undefined ->b : string - -Iterator.zipKeyed(p); ->Iterator.zipKeyed(p) : IteratorObject<{ a?: number | undefined; } | { b: never; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->p : { a?: Iterable; } | { b: string; } - -declare const q: { a: Iterable; } | { b: undefined; }; ->q : { a: Iterable; } | { b: undefined; } ->a : Iterable ->b : undefined - -const r: { a: number; }[] = Iterator.zipKeyed(q).toArray(); ->r : { a: number; }[] ->a : number ->Iterator.zipKeyed(q).toArray() : { a: number; }[] ->Iterator.zipKeyed(q).toArray : () => { a: number; }[] ->Iterator.zipKeyed(q) : IteratorObject<{ a: number; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->q : { a: Iterable; } | { b: undefined; } ->toArray : () => { a: number; }[] - -declare const s: unique symbol; ->s : unique symbol - -declare const t: { a: Iterable; [s]?: Iterable; }; ->t : { a: Iterable; [s]?: Iterable; } ->a : Iterable ->[s] : Iterable | undefined ->s : unique symbol - -const u: { a: number; [s]?: string; }[] = Iterator.zipKeyed(t).toArray(); ->u : { a: number; [s]?: string; }[] ->a : number ->[s] : string | undefined ->s : unique symbol ->Iterator.zipKeyed(t).toArray() : { a: number; [s]?: string | undefined; }[] ->Iterator.zipKeyed(t).toArray : () => { a: number; [s]?: string | undefined; }[] ->Iterator.zipKeyed(t) : IteratorObject<{ a: number; [s]?: string | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->t : { a: Iterable; [s]?: Iterable; } ->toArray : () => { a: number; [s]?: string | undefined; }[] - -Iterator.zipKeyed({ a: [1], b: null }); ->Iterator.zipKeyed({ a: [1], b: null }) : IteratorObject<{ a: number; b: never; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ a: [1], b: null } : { a: number[]; b: null; } ->a : number[] ->[1] : number[] ->1 : 1 ->b : null - -Iterator.zipKeyed({ a: [1], b: false }); ->Iterator.zipKeyed({ a: [1], b: false }) : IteratorObject<{ a: number; b: never; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ a: [1], b: false } : { a: number[]; b: boolean; } ->a : number[] ->[1] : number[] ->1 : 1 ->b : boolean ->false : false - -Iterator.zip([undefined]); ->Iterator.zip([undefined]) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->[undefined] : [undefined] ->undefined : undefined - -declare const v: { a?: undefined; }; ->v : { a?: undefined; } ->a : undefined - -const w: never[] = Iterator.zipKeyed(v).toArray(); ->w : never[] ->Iterator.zipKeyed(v).toArray() : never[] ->Iterator.zipKeyed(v).toArray : () => never[] ->Iterator.zipKeyed(v) : IteratorObject ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->v : { a?: undefined; } ->toArray : () => never[] - -const x: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); ->x : { a: number; }[] ->a : number ->Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray() : { a: number; }[] ->Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray : () => { a: number; }[] ->Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }) : IteratorObject<{ a: number; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ a: [1], b: undefined } : { a: number[]; b: undefined; } ->a : number[] ->[1] : number[] ->1 : 1 ->b : undefined ->undefined : undefined ->{ mode: "longest", padding: { a: 0 } } : { mode: "longest"; padding: { a: number; }; } ->mode : "longest" ->"longest" : "longest" ->padding : { a: number; } ->{ a: 0 } : { a: number; } ->a : number ->0 : 0 ->toArray : () => { a: number; }[] - -const y: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); ->y : { a: number | undefined; }[] ->a : number | undefined ->Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray() : { a: number | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray : () => { a: number | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }) : IteratorObject<{ a: number | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ a: [1], b: undefined } : { a: number[]; b: undefined; } ->a : number[] ->[1] : number[] ->1 : 1 ->b : undefined ->undefined : undefined ->{ mode: "longest" } : { mode: "longest"; } ->mode : "longest" ->"longest" : "longest" ->toArray : () => { a: number | undefined; }[] - -function f1(a: Iterable) { ->f1 : (a: Iterable) => { b: { a: T; }[]; c: [T][]; } ->a : Iterable - - const b: { a: T; }[] = Iterator.zipKeyed({ a }).toArray(); ->b : { a: T; }[] ->a : T ->Iterator.zipKeyed({ a }).toArray() : { a: T; }[] ->Iterator.zipKeyed({ a }).toArray : () => { a: T; }[] ->Iterator.zipKeyed({ a }) : IteratorObject<{ a: T; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K] | undefined; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K] | undefined; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K] | undefined; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K] | undefined; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K] | undefined; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K] | undefined; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ a } : { a: Iterable; } ->a : Iterable ->toArray : () => { a: T; }[] - - const c: [T][] = Iterator.zip([a]).toArray(); ->c : [T][] ->Iterator.zip([a]).toArray() : [T][] ->Iterator.zip([a]).toArray : () => [T][] ->Iterator.zip([a]) : IteratorObject<[T], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T_1, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T_1, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T_1, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T_1 extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T_1 extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T_1, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T_1, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T_1, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T_1 extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T_1 extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->[a] : [Iterable] ->a : Iterable ->toArray : () => [T][] - - return { b, c }; ->{ b, c } : { b: { a: T; }[]; c: [T][]; } ->b : { a: T; }[] ->c : [T][] -} - diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=true).errors.txt b/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=true).errors.txt deleted file mode 100644 index 129663dd36d57..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=true).errors.txt +++ /dev/null @@ -1,262 +0,0 @@ -iteratorZipInputs.ts(1,14): error TS2769: No overload matches this call. - The last overload gave the following error. - Argument of type 'string' is not assignable to parameter of type 'Iterable> & object'. - Type 'string' is not assignable to type 'Iterable>'. -iteratorZipInputs.ts(2,14): error TS2769: No overload matches this call. - The last overload gave the following error. - Argument of type 'string[]' is not assignable to parameter of type 'Iterable> & object'. - Type 'string[]' is not assignable to type 'Iterable>'. - The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. - Type 'IteratorResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. - Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. - Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. - Type 'string' is not assignable to type 'IteratorInput'. -iteratorZipInputs.ts(3,14): error TS2769: No overload matches this call. - The last overload gave the following error. - Argument of type 'Set' is not assignable to parameter of type 'Iterable> & object'. - Type 'Set' is not assignable to type 'Iterable>'. - The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. - Type 'IteratorResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. - Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. - Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. - Type 'string' is not assignable to type 'IteratorInput'. -iteratorZipInputs.ts(4,19): error TS2345: Argument of type 'string' is not assignable to parameter of type 'object & IteratorZipKeyedInput'. - Type 'string' is not assignable to type 'object'. -iteratorZipInputs.ts(5,21): error TS2322: Type 'string' is not assignable to type 'never'. -iteratorZipInputs.ts(6,37): error TS2769: No overload matches this call. - The last overload gave the following error. - Type 'string' is not assignable to type 'Iterable & object'. - Type 'string' is not assignable to type 'Iterable'. -iteratorZipInputs.ts(7,42): error TS2769: No overload matches this call. - The last overload gave the following error. - Type 'string' is not assignable to type 'Iterable & object'. - Type 'string' is not assignable to type 'object'. -iteratorZipInputs.ts(8,42): error TS2769: No overload matches this call. - The last overload gave the following error. - Type 'string' is not assignable to type 'object'. -iteratorZipInputs.ts(16,6): error TS2339: Property 'b' does not exist on type 'IteratorZipResult<{ a: number[]; } & {}, never, {}>'. -iteratorZipInputs.ts(32,6): error TS2339: Property 'd' does not exist on type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator; readonly c?: Iterable | undefined; }, never, {}>'. -iteratorZipInputs.ts(33,7): error TS2322: Type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator; readonly c?: Iterable | undefined; }, never, {}>[]' is not assignable to type '{ a: number; c: boolean; }[]'. - Type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator; readonly c?: Iterable | undefined; }, never, {}>' is not assignable to type '{ a: number; c: boolean; }'. - Property 'c' is optional in type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator; readonly c?: Iterable | undefined; }, never, {}>' but required in type '{ a: number; c: boolean; }'. -iteratorZipInputs.ts(39,19): error TS2345: Argument of type '{ a: Iterable; } | { b: number; }' is not assignable to parameter of type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. - Type '{ b: number; }' is not assignable to type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. - Type '{ b: number; }' is not assignable to type '{ b: number; } & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. - Type '{ b: number; }' is not assignable to type 'IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. - Types of property 'b' are incompatible. - Type 'number' is not assignable to type 'IteratorInput | undefined'. -iteratorZipInputs.ts(40,19): error TS2769: No overload matches this call. - The last overload gave the following error. - Argument of type '{ a: Iterable; } | { b: number; }' is not assignable to parameter of type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. - Type '{ b: number; }' is not assignable to type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. - Type '{ b: number; }' is not assignable to type '{ b: number; } & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. - Type '{ b: number; }' is not assignable to type 'IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. - Types of property 'b' are incompatible. - Type 'number' is not assignable to type 'IteratorInput | undefined'. -iteratorZipInputs.ts(41,19): error TS2769: No overload matches this call. - The last overload gave the following error. - Argument of type '{ a: Iterable; } | { b: number; }' is not assignable to parameter of type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. - Type '{ b: number; }' is not assignable to type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. - Type '{ b: number; }' is not assignable to type '{ b: number; } & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. - Type '{ b: number; }' is not assignable to type 'IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. - Types of property 'b' are incompatible. - Type 'number' is not assignable to type 'IteratorInput | undefined'. -iteratorZipInputs.ts(43,19): error TS2345: Argument of type '{ a?: Iterable; } | { b: string; }' is not assignable to parameter of type '({ a?: Iterable; } | { b: string; }) & IteratorZipKeyedInput<{ a?: Iterable; } | { b: string; }>'. - Type '{ b: string; }' is not assignable to type '({ a?: Iterable; } | { b: string; }) & IteratorZipKeyedInput<{ a?: Iterable; } | { b: string; }>'. - Type '{ b: string; }' is not assignable to type '{ b: string; } & IteratorZipKeyedInput<{ a?: Iterable; } | { b: string; }>'. - Type '{ b: string; }' is not assignable to type 'IteratorZipKeyedInput<{ a?: Iterable; } | { b: string; }>'. - Types of property 'b' are incompatible. - Type 'string' is not assignable to type 'IteratorInput | undefined'. -iteratorZipInputs.ts(51,21): error TS2322: Type 'number[]' is not assignable to type 'never'. -iteratorZipInputs.ts(51,29): error TS2322: Type 'null' is not assignable to type 'never'. -iteratorZipInputs.ts(52,21): error TS2322: Type 'number[]' is not assignable to type 'never'. -iteratorZipInputs.ts(52,29): error TS2322: Type 'false' is not assignable to type 'never'. -iteratorZipInputs.ts(53,14): error TS2769: No overload matches this call. - The last overload gave the following error. - Argument of type 'undefined[]' is not assignable to parameter of type 'Iterable> & object'. - Type 'undefined[]' is not assignable to type 'Iterable>'. - The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. - Type 'IteratorResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. - Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. - Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. - Type 'undefined' is not assignable to type 'IteratorInput'. - - -==== iteratorZipInputs.ts (20 errors) ==== - Iterator.zip("ab"); - ~~~~ -!!! error TS2769: No overload matches this call. -!!! error TS2769: The last overload gave the following error. -!!! error TS2769: Argument of type 'string' is not assignable to parameter of type 'Iterable> & object'. -!!! error TS2769: Type 'string' is not assignable to type 'Iterable>'. -!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. - Iterator.zip(["ab"]); - ~~~~~~ -!!! error TS2769: No overload matches this call. -!!! error TS2769: The last overload gave the following error. -!!! error TS2769: Argument of type 'string[]' is not assignable to parameter of type 'Iterable> & object'. -!!! error TS2769: Type 'string[]' is not assignable to type 'Iterable>'. -!!! error TS2769: The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. -!!! error TS2769: Type 'IteratorResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. -!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. -!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. -!!! error TS2769: Type 'string' is not assignable to type 'IteratorInput'. -!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. - Iterator.zip(new Set(["ab"])); - ~~~~~~~~~~~~~~~ -!!! error TS2769: No overload matches this call. -!!! error TS2769: The last overload gave the following error. -!!! error TS2769: Argument of type 'Set' is not assignable to parameter of type 'Iterable> & object'. -!!! error TS2769: Type 'Set' is not assignable to type 'Iterable>'. -!!! error TS2769: The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. -!!! error TS2769: Type 'IteratorResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. -!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. -!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. -!!! error TS2769: Type 'string' is not assignable to type 'IteratorInput'. -!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. - Iterator.zipKeyed("ab"); - ~~~~ -!!! error TS2345: Argument of type 'string' is not assignable to parameter of type 'object & IteratorZipKeyedInput'. -!!! error TS2345: Type 'string' is not assignable to type 'object'. - Iterator.zipKeyed({ a: "ab" }); - ~ -!!! error TS2322: Type 'string' is not assignable to type 'never'. -!!! related TS6500 iteratorZipInputs.ts:5:21: The expected type comes from property 'a' which is declared here on type '{ a: string; } & IteratorZipKeyedInput<{ a: string; }>' - Iterator.zip([], { mode: "longest", padding: "ab" }); - ~~~~~~~ -!!! error TS2769: No overload matches this call. -!!! error TS2769: The last overload gave the following error. -!!! error TS2769: Type 'string' is not assignable to type 'Iterable & object'. -!!! error TS2769: Type 'string' is not assignable to type 'Iterable'. -!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. - Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); - ~~~~~~~ -!!! error TS2769: No overload matches this call. -!!! error TS2769: The last overload gave the following error. -!!! error TS2769: Type 'string' is not assignable to type 'Iterable & object'. -!!! error TS2769: Type 'string' is not assignable to type 'object'. -!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. - Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); - ~~~~~~~ -!!! error TS2769: No overload matches this call. -!!! error TS2769: The last overload gave the following error. -!!! error TS2769: Type 'string' is not assignable to type 'object'. -!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. - - const a: [string][] = Iterator.zip([new String("ab")]).toArray(); - const b: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); - const c: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); - - const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); - const e: { a: number; }[] = d; - d[0].b; - ~ -!!! error TS2339: Property 'b' does not exist on type 'IteratorZipResult<{ a: number[]; } & {}, never, {}>'. - const f: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); - const g: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); - - interface I { - readonly a: Iterable; - readonly b?: Iterator; - readonly c: Iterable | undefined; - readonly d?: undefined; - } - declare const h: I; - const i = Iterator.zipKeyed(h).toArray(); - const j: { a: number; b?: string; c?: boolean; }[] = i; - i[0].a = 2; - i[0].b = "a"; - i[0].c = true; - i[0].d; - ~ -!!! error TS2339: Property 'd' does not exist on type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator; readonly c?: Iterable | undefined; }, never, {}>'. - const k: { a: number; c: boolean; }[] = i; - ~ -!!! error TS2322: Type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator; readonly c?: Iterable | undefined; }, never, {}>[]' is not assignable to type '{ a: number; c: boolean; }[]'. -!!! error TS2322: Type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator; readonly c?: Iterable | undefined; }, never, {}>' is not assignable to type '{ a: number; c: boolean; }'. -!!! error TS2322: Property 'c' is optional in type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator; readonly c?: Iterable | undefined; }, never, {}>' but required in type '{ a: number; c: boolean; }'. - const l: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); - - declare const m: { a: Iterable; } | { b: Iterator; }; - const n: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(m).toArray(); - declare const o: { a: Iterable; } | { b: number; }; - Iterator.zipKeyed(o); - ~ -!!! error TS2345: Argument of type '{ a: Iterable; } | { b: number; }' is not assignable to parameter of type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. -!!! error TS2345: Type '{ b: number; }' is not assignable to type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. -!!! error TS2345: Type '{ b: number; }' is not assignable to type '{ b: number; } & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. -!!! error TS2345: Type '{ b: number; }' is not assignable to type 'IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. -!!! error TS2345: Types of property 'b' are incompatible. -!!! error TS2345: Type 'number' is not assignable to type 'IteratorInput | undefined'. - Iterator.zipKeyed(o, { mode: "longest" }); - ~ -!!! error TS2769: No overload matches this call. -!!! error TS2769: The last overload gave the following error. -!!! error TS2769: Argument of type '{ a: Iterable; } | { b: number; }' is not assignable to parameter of type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. -!!! error TS2769: Type '{ b: number; }' is not assignable to type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. -!!! error TS2769: Type '{ b: number; }' is not assignable to type '{ b: number; } & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. -!!! error TS2769: Type '{ b: number; }' is not assignable to type 'IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. -!!! error TS2769: Types of property 'b' are incompatible. -!!! error TS2769: Type 'number' is not assignable to type 'IteratorInput | undefined'. -!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. - Iterator.zipKeyed(o, { mode: "longest", padding: {} }); - ~ -!!! error TS2769: No overload matches this call. -!!! error TS2769: The last overload gave the following error. -!!! error TS2769: Argument of type '{ a: Iterable; } | { b: number; }' is not assignable to parameter of type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. -!!! error TS2769: Type '{ b: number; }' is not assignable to type '({ a: Iterable; } | { b: number; }) & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. -!!! error TS2769: Type '{ b: number; }' is not assignable to type '{ b: number; } & IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. -!!! error TS2769: Type '{ b: number; }' is not assignable to type 'IteratorZipKeyedInput<{ a: Iterable; } | { b: number; }>'. -!!! error TS2769: Types of property 'b' are incompatible. -!!! error TS2769: Type 'number' is not assignable to type 'IteratorInput | undefined'. -!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. - declare const p: { a?: Iterable; } | { b: string; }; - Iterator.zipKeyed(p); - ~ -!!! error TS2345: Argument of type '{ a?: Iterable; } | { b: string; }' is not assignable to parameter of type '({ a?: Iterable; } | { b: string; }) & IteratorZipKeyedInput<{ a?: Iterable; } | { b: string; }>'. -!!! error TS2345: Type '{ b: string; }' is not assignable to type '({ a?: Iterable; } | { b: string; }) & IteratorZipKeyedInput<{ a?: Iterable; } | { b: string; }>'. -!!! error TS2345: Type '{ b: string; }' is not assignable to type '{ b: string; } & IteratorZipKeyedInput<{ a?: Iterable; } | { b: string; }>'. -!!! error TS2345: Type '{ b: string; }' is not assignable to type 'IteratorZipKeyedInput<{ a?: Iterable; } | { b: string; }>'. -!!! error TS2345: Types of property 'b' are incompatible. -!!! error TS2345: Type 'string' is not assignable to type 'IteratorInput | undefined'. - declare const q: { a: Iterable; } | { b: undefined; }; - const r: { a: number; }[] = Iterator.zipKeyed(q).toArray(); - - declare const s: unique symbol; - declare const t: { a: Iterable; [s]?: Iterable; }; - const u: { a: number; [s]?: string; }[] = Iterator.zipKeyed(t).toArray(); - - Iterator.zipKeyed({ a: [1], b: null }); - ~ -!!! error TS2322: Type 'number[]' is not assignable to type 'never'. - ~ -!!! error TS2322: Type 'null' is not assignable to type 'never'. - Iterator.zipKeyed({ a: [1], b: false }); - ~ -!!! error TS2322: Type 'number[]' is not assignable to type 'never'. - ~ -!!! error TS2322: Type 'false' is not assignable to type 'never'. - Iterator.zip([undefined]); - ~~~~~~~~~~~ -!!! error TS2769: No overload matches this call. -!!! error TS2769: The last overload gave the following error. -!!! error TS2769: Argument of type 'undefined[]' is not assignable to parameter of type 'Iterable> & object'. -!!! error TS2769: Type 'undefined[]' is not assignable to type 'Iterable>'. -!!! error TS2769: The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. -!!! error TS2769: Type 'IteratorResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. -!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. -!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. -!!! error TS2769: Type 'undefined' is not assignable to type 'IteratorInput'. -!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. - - declare const v: { a?: undefined; }; - const w: never[] = Iterator.zipKeyed(v).toArray(); - const x: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); - const y: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); - - function f1(a: Iterable) { - const b: { a: T; }[] = Iterator.zipKeyed({ a }).toArray(); - const c: [T][] = Iterator.zip([a]).toArray(); - return { b, c }; - } - \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=true).js b/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=true).js deleted file mode 100644 index 0db719cfcb44a..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=true).js +++ /dev/null @@ -1,208 +0,0 @@ -//// [tests/cases/compiler/iteratorZipInputs.ts] //// - -//// [iteratorZipInputs.ts] -Iterator.zip("ab"); -Iterator.zip(["ab"]); -Iterator.zip(new Set(["ab"])); -Iterator.zipKeyed("ab"); -Iterator.zipKeyed({ a: "ab" }); -Iterator.zip([], { mode: "longest", padding: "ab" }); -Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); -Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); - -const a: [string][] = Iterator.zip([new String("ab")]).toArray(); -const b: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); -const c: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); - -const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); -const e: { a: number; }[] = d; -d[0].b; -const f: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); -const g: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); - -interface I { - readonly a: Iterable; - readonly b?: Iterator; - readonly c: Iterable | undefined; - readonly d?: undefined; -} -declare const h: I; -const i = Iterator.zipKeyed(h).toArray(); -const j: { a: number; b?: string; c?: boolean; }[] = i; -i[0].a = 2; -i[0].b = "a"; -i[0].c = true; -i[0].d; -const k: { a: number; c: boolean; }[] = i; -const l: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); - -declare const m: { a: Iterable; } | { b: Iterator; }; -const n: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(m).toArray(); -declare const o: { a: Iterable; } | { b: number; }; -Iterator.zipKeyed(o); -Iterator.zipKeyed(o, { mode: "longest" }); -Iterator.zipKeyed(o, { mode: "longest", padding: {} }); -declare const p: { a?: Iterable; } | { b: string; }; -Iterator.zipKeyed(p); -declare const q: { a: Iterable; } | { b: undefined; }; -const r: { a: number; }[] = Iterator.zipKeyed(q).toArray(); - -declare const s: unique symbol; -declare const t: { a: Iterable; [s]?: Iterable; }; -const u: { a: number; [s]?: string; }[] = Iterator.zipKeyed(t).toArray(); - -Iterator.zipKeyed({ a: [1], b: null }); -Iterator.zipKeyed({ a: [1], b: false }); -Iterator.zip([undefined]); - -declare const v: { a?: undefined; }; -const w: never[] = Iterator.zipKeyed(v).toArray(); -const x: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); -const y: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); - -function f1(a: Iterable) { - const b: { a: T; }[] = Iterator.zipKeyed({ a }).toArray(); - const c: [T][] = Iterator.zip([a]).toArray(); - return { b, c }; -} - - -//// [iteratorZipInputs.js] -"use strict"; -Iterator.zip("ab"); -Iterator.zip(["ab"]); -Iterator.zip(new Set(["ab"])); -Iterator.zipKeyed("ab"); -Iterator.zipKeyed({ a: "ab" }); -Iterator.zip([], { mode: "longest", padding: "ab" }); -Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); -Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); -const a = Iterator.zip([new String("ab")]).toArray(); -const b = Iterator.zipKeyed({ a: new String("ab") }).toArray(); -const c = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); -const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); -const e = d; -d[0].b; -const f = Iterator.zipKeyed({ a: undefined }).toArray(); -const g = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); -const i = Iterator.zipKeyed(h).toArray(); -const j = i; -i[0].a = 2; -i[0].b = "a"; -i[0].c = true; -i[0].d; -const k = i; -const l = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); -const n = Iterator.zipKeyed(m).toArray(); -Iterator.zipKeyed(o); -Iterator.zipKeyed(o, { mode: "longest" }); -Iterator.zipKeyed(o, { mode: "longest", padding: {} }); -Iterator.zipKeyed(p); -const r = Iterator.zipKeyed(q).toArray(); -const u = Iterator.zipKeyed(t).toArray(); -Iterator.zipKeyed({ a: [1], b: null }); -Iterator.zipKeyed({ a: [1], b: false }); -Iterator.zip([undefined]); -const w = Iterator.zipKeyed(v).toArray(); -const x = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); -const y = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); -function f1(a) { - const b = Iterator.zipKeyed({ a }).toArray(); - const c = Iterator.zip([a]).toArray(); - return { b, c }; -} - - -//// [iteratorZipInputs.d.ts] -declare const a: [string][]; -declare const b: { - a: string; -}[]; -declare const c: (string | undefined)[][]; -declare const d: { - a: number; -}[]; -declare const e: { - a: number; -}[]; -declare const f: never[]; -declare const g: never[]; -interface I { - readonly a: Iterable; - readonly b?: Iterator; - readonly c: Iterable | undefined; - readonly d?: undefined; -} -declare const h: I; -declare const i: { - a: number; - b?: string; - c?: boolean; -}[]; -declare const j: { - a: number; - b?: string; - c?: boolean; -}[]; -declare const k: { - a: number; - c: boolean; -}[]; -declare const l: { - a: number | undefined; - b?: string | undefined; - c?: boolean | undefined; -}[]; -declare const m: { - a: Iterable; -} | { - b: Iterator; -}; -declare const n: ({ - a: number; -} | { - b: string; -})[]; -declare const o: { - a: Iterable; -} | { - b: number; -}; -declare const p: { - a?: Iterable; -} | { - b: string; -}; -declare const q: { - a: Iterable; -} | { - b: undefined; -}; -declare const r: { - a: number; -}[]; -declare const s: unique symbol; -declare const t: { - a: Iterable; - [s]?: Iterable; -}; -declare const u: { - a: number; - [s]?: string; -}[]; -declare const v: { - a?: undefined; -}; -declare const w: never[]; -declare const x: { - a: number; -}[]; -declare const y: { - a: number | undefined; -}[]; -declare function f1(a: Iterable): { - b: { - a: T; - }[]; - c: [T][]; -}; diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=true).symbols b/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=true).symbols deleted file mode 100644 index b9e998282517a..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=true).symbols +++ /dev/null @@ -1,388 +0,0 @@ -//// [tests/cases/compiler/iteratorZipInputs.ts] //// - -=== iteratorZipInputs.ts === -Iterator.zip("ab"); ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) - -Iterator.zip(["ab"]); ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) - -Iterator.zip(new Set(["ab"])); ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Set : Symbol(Set, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) - -Iterator.zipKeyed("ab"); ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) - -Iterator.zipKeyed({ a: "ab" }); ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 4, 19)) - -Iterator.zip([], { mode: "longest", padding: "ab" }); ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZipInputs.ts, 5, 18)) ->padding : Symbol(padding, Decl(iteratorZipInputs.ts, 5, 35)) - -Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZipInputs.ts, 6, 23)) ->padding : Symbol(padding, Decl(iteratorZipInputs.ts, 6, 40)) - -Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->mode : Symbol(mode, Decl(iteratorZipInputs.ts, 7, 23)) ->padding : Symbol(padding, Decl(iteratorZipInputs.ts, 7, 40)) - -const a: [string][] = Iterator.zip([new String("ab")]).toArray(); ->a : Symbol(a, Decl(iteratorZipInputs.ts, 9, 5)) ->Iterator.zip([new String("ab")]).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const b: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); ->b : Symbol(b, Decl(iteratorZipInputs.ts, 10, 5)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 10, 10)) ->Iterator.zipKeyed({ a: new String("ab") }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 10, 47)) ->String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const c: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); ->c : Symbol(c, Decl(iteratorZipInputs.ts, 11, 5)) ->Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZipInputs.ts, 11, 59)) ->padding : Symbol(padding, Decl(iteratorZipInputs.ts, 11, 76)) ->String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); ->d : Symbol(d, Decl(iteratorZipInputs.ts, 13, 5)) ->Iterator.zipKeyed({ a: [1], b: undefined }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 13, 29)) ->b : Symbol(b, Decl(iteratorZipInputs.ts, 13, 37)) ->undefined : Symbol(undefined) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const e: { a: number; }[] = d; ->e : Symbol(e, Decl(iteratorZipInputs.ts, 14, 5)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 14, 10)) ->d : Symbol(d, Decl(iteratorZipInputs.ts, 13, 5)) - -d[0].b; ->d : Symbol(d, Decl(iteratorZipInputs.ts, 13, 5)) - -const f: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); ->f : Symbol(f, Decl(iteratorZipInputs.ts, 16, 5)) ->Iterator.zipKeyed({ a: undefined }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 16, 38)) ->undefined : Symbol(undefined) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const g: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); ->g : Symbol(g, Decl(iteratorZipInputs.ts, 17, 5)) ->Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 17, 38)) ->undefined : Symbol(undefined) ->mode : Symbol(mode, Decl(iteratorZipInputs.ts, 17, 56)) ->padding : Symbol(padding, Decl(iteratorZipInputs.ts, 17, 73)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -interface I { ->I : Symbol(I, Decl(iteratorZipInputs.ts, 17, 99)) - - readonly a: Iterable; ->a : Symbol(I.a, Decl(iteratorZipInputs.ts, 19, 13)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) - - readonly b?: Iterator; ->b : Symbol(I.b, Decl(iteratorZipInputs.ts, 20, 33)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) - - readonly c: Iterable | undefined; ->c : Symbol(I.c, Decl(iteratorZipInputs.ts, 21, 34)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) - - readonly d?: undefined; ->d : Symbol(I.d, Decl(iteratorZipInputs.ts, 22, 46)) -} -declare const h: I; ->h : Symbol(h, Decl(iteratorZipInputs.ts, 25, 13)) ->I : Symbol(I, Decl(iteratorZipInputs.ts, 17, 99)) - -const i = Iterator.zipKeyed(h).toArray(); ->i : Symbol(i, Decl(iteratorZipInputs.ts, 26, 5)) ->Iterator.zipKeyed(h).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->h : Symbol(h, Decl(iteratorZipInputs.ts, 25, 13)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const j: { a: number; b?: string; c?: boolean; }[] = i; ->j : Symbol(j, Decl(iteratorZipInputs.ts, 27, 5)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 27, 10)) ->b : Symbol(b, Decl(iteratorZipInputs.ts, 27, 21)) ->c : Symbol(c, Decl(iteratorZipInputs.ts, 27, 33)) ->i : Symbol(i, Decl(iteratorZipInputs.ts, 26, 5)) - -i[0].a = 2; ->i[0].a : Symbol(a, Decl(iteratorZipInputs.ts, 19, 13)) ->i : Symbol(i, Decl(iteratorZipInputs.ts, 26, 5)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 19, 13)) - -i[0].b = "a"; ->i[0].b : Symbol(b, Decl(iteratorZipInputs.ts, 20, 33)) ->i : Symbol(i, Decl(iteratorZipInputs.ts, 26, 5)) ->b : Symbol(b, Decl(iteratorZipInputs.ts, 20, 33)) - -i[0].c = true; ->i[0].c : Symbol(c, Decl(iteratorZipInputs.ts, 21, 34)) ->i : Symbol(i, Decl(iteratorZipInputs.ts, 26, 5)) ->c : Symbol(c, Decl(iteratorZipInputs.ts, 21, 34)) - -i[0].d; ->i : Symbol(i, Decl(iteratorZipInputs.ts, 26, 5)) - -const k: { a: number; c: boolean; }[] = i; ->k : Symbol(k, Decl(iteratorZipInputs.ts, 32, 5)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 32, 10)) ->c : Symbol(c, Decl(iteratorZipInputs.ts, 32, 21)) ->i : Symbol(i, Decl(iteratorZipInputs.ts, 26, 5)) - -const l: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); ->l : Symbol(l, Decl(iteratorZipInputs.ts, 33, 5)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 33, 10)) ->b : Symbol(b, Decl(iteratorZipInputs.ts, 33, 33)) ->c : Symbol(c, Decl(iteratorZipInputs.ts, 33, 57)) ->Iterator.zipKeyed(h, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->h : Symbol(h, Decl(iteratorZipInputs.ts, 25, 13)) ->mode : Symbol(mode, Decl(iteratorZipInputs.ts, 33, 111)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -declare const m: { a: Iterable; } | { b: Iterator; }; ->m : Symbol(m, Decl(iteratorZipInputs.ts, 35, 13)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 35, 18)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->b : Symbol(b, Decl(iteratorZipInputs.ts, 35, 45)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) - -const n: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(m).toArray(); ->n : Symbol(n, Decl(iteratorZipInputs.ts, 36, 5)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 36, 11)) ->b : Symbol(b, Decl(iteratorZipInputs.ts, 36, 28)) ->Iterator.zipKeyed(m).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->m : Symbol(m, Decl(iteratorZipInputs.ts, 35, 13)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -declare const o: { a: Iterable; } | { b: number; }; ->o : Symbol(o, Decl(iteratorZipInputs.ts, 37, 13)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 37, 18)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->b : Symbol(b, Decl(iteratorZipInputs.ts, 37, 45)) - -Iterator.zipKeyed(o); ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->o : Symbol(o, Decl(iteratorZipInputs.ts, 37, 13)) - -Iterator.zipKeyed(o, { mode: "longest" }); ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->o : Symbol(o, Decl(iteratorZipInputs.ts, 37, 13)) ->mode : Symbol(mode, Decl(iteratorZipInputs.ts, 39, 22)) - -Iterator.zipKeyed(o, { mode: "longest", padding: {} }); ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->o : Symbol(o, Decl(iteratorZipInputs.ts, 37, 13)) ->mode : Symbol(mode, Decl(iteratorZipInputs.ts, 40, 22)) ->padding : Symbol(padding, Decl(iteratorZipInputs.ts, 40, 39)) - -declare const p: { a?: Iterable; } | { b: string; }; ->p : Symbol(p, Decl(iteratorZipInputs.ts, 41, 13)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 41, 18)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->b : Symbol(b, Decl(iteratorZipInputs.ts, 41, 46)) - -Iterator.zipKeyed(p); ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->p : Symbol(p, Decl(iteratorZipInputs.ts, 41, 13)) - -declare const q: { a: Iterable; } | { b: undefined; }; ->q : Symbol(q, Decl(iteratorZipInputs.ts, 43, 13)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 43, 18)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->b : Symbol(b, Decl(iteratorZipInputs.ts, 43, 45)) - -const r: { a: number; }[] = Iterator.zipKeyed(q).toArray(); ->r : Symbol(r, Decl(iteratorZipInputs.ts, 44, 5)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 44, 10)) ->Iterator.zipKeyed(q).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->q : Symbol(q, Decl(iteratorZipInputs.ts, 43, 13)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -declare const s: unique symbol; ->s : Symbol(s, Decl(iteratorZipInputs.ts, 46, 13)) - -declare const t: { a: Iterable; [s]?: Iterable; }; ->t : Symbol(t, Decl(iteratorZipInputs.ts, 47, 13)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 47, 18)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->[s] : Symbol([s], Decl(iteratorZipInputs.ts, 47, 39)) ->s : Symbol(s, Decl(iteratorZipInputs.ts, 46, 13)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) - -const u: { a: number; [s]?: string; }[] = Iterator.zipKeyed(t).toArray(); ->u : Symbol(u, Decl(iteratorZipInputs.ts, 48, 5)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 48, 10)) ->[s] : Symbol([s], Decl(iteratorZipInputs.ts, 48, 21)) ->s : Symbol(s, Decl(iteratorZipInputs.ts, 46, 13)) ->Iterator.zipKeyed(t).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->t : Symbol(t, Decl(iteratorZipInputs.ts, 47, 13)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -Iterator.zipKeyed({ a: [1], b: null }); ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 50, 19)) ->b : Symbol(b, Decl(iteratorZipInputs.ts, 50, 27)) - -Iterator.zipKeyed({ a: [1], b: false }); ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 51, 19)) ->b : Symbol(b, Decl(iteratorZipInputs.ts, 51, 27)) - -Iterator.zip([undefined]); ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->undefined : Symbol(undefined) - -declare const v: { a?: undefined; }; ->v : Symbol(v, Decl(iteratorZipInputs.ts, 54, 13)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 54, 18)) - -const w: never[] = Iterator.zipKeyed(v).toArray(); ->w : Symbol(w, Decl(iteratorZipInputs.ts, 55, 5)) ->Iterator.zipKeyed(v).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->v : Symbol(v, Decl(iteratorZipInputs.ts, 54, 13)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const x: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); ->x : Symbol(x, Decl(iteratorZipInputs.ts, 56, 5)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 56, 10)) ->Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 56, 47)) ->b : Symbol(b, Decl(iteratorZipInputs.ts, 56, 55)) ->undefined : Symbol(undefined) ->mode : Symbol(mode, Decl(iteratorZipInputs.ts, 56, 73)) ->padding : Symbol(padding, Decl(iteratorZipInputs.ts, 56, 90)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 56, 101)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const y: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); ->y : Symbol(y, Decl(iteratorZipInputs.ts, 57, 5)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 57, 10)) ->Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 57, 59)) ->b : Symbol(b, Decl(iteratorZipInputs.ts, 57, 67)) ->undefined : Symbol(undefined) ->mode : Symbol(mode, Decl(iteratorZipInputs.ts, 57, 85)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -function f1(a: Iterable) { ->f1 : Symbol(f1, Decl(iteratorZipInputs.ts, 57, 115)) ->T : Symbol(T, Decl(iteratorZipInputs.ts, 59, 12)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 59, 15)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->T : Symbol(T, Decl(iteratorZipInputs.ts, 59, 12)) - - const b: { a: T; }[] = Iterator.zipKeyed({ a }).toArray(); ->b : Symbol(b, Decl(iteratorZipInputs.ts, 60, 9)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 60, 14)) ->T : Symbol(T, Decl(iteratorZipInputs.ts, 59, 12)) ->Iterator.zipKeyed({ a }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 60, 46)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - - const c: [T][] = Iterator.zip([a]).toArray(); ->c : Symbol(c, Decl(iteratorZipInputs.ts, 61, 9)) ->T : Symbol(T, Decl(iteratorZipInputs.ts, 59, 12)) ->Iterator.zip([a]).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->a : Symbol(a, Decl(iteratorZipInputs.ts, 59, 15)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - - return { b, c }; ->b : Symbol(b, Decl(iteratorZipInputs.ts, 62, 12)) ->c : Symbol(c, Decl(iteratorZipInputs.ts, 62, 15)) -} - diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=true).types b/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=true).types deleted file mode 100644 index cfaab4fb9af24..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/iteratorZipInputs(exactoptionalpropertytypes=true).types +++ /dev/null @@ -1,511 +0,0 @@ -//// [tests/cases/compiler/iteratorZipInputs.ts] //// - -=== iteratorZipInputs.ts === -Iterator.zip("ab"); ->Iterator.zip("ab") : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->"ab" : "ab" - -Iterator.zip(["ab"]); ->Iterator.zip(["ab"]) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->["ab"] : [string] ->"ab" : "ab" - -Iterator.zip(new Set(["ab"])); ->Iterator.zip(new Set(["ab"])) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->new Set(["ab"]) : Set ->Set : SetConstructor ->["ab"] : string[] ->"ab" : "ab" - -Iterator.zipKeyed("ab"); ->Iterator.zipKeyed("ab") : IteratorObject ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->"ab" : "ab" - -Iterator.zipKeyed({ a: "ab" }); ->Iterator.zipKeyed({ a: "ab" }) : IteratorObject<{ a: never; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ a: "ab" } : { a: string; } ->a : string ->"ab" : "ab" - -Iterator.zip([], { mode: "longest", padding: "ab" }); ->Iterator.zip([], { mode: "longest", padding: "ab" }) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->[] : [] ->{ mode: "longest", padding: "ab" } : { mode: "longest"; padding: string; } ->mode : "longest" ->"longest" : "longest" ->padding : string ->"ab" : "ab" - -Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); ->Iterator.zip([["a"]], { mode: "longest", padding: "ab" }) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->[["a"]] : [string[]] ->["a"] : string[] ->"a" : "a" ->{ mode: "longest", padding: "ab" } : { mode: "longest"; padding: string; } ->mode : "longest" ->"longest" : "longest" ->padding : string ->"ab" : "ab" - -Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); ->Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }) : IteratorObject ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{} : {} ->{ mode: "longest", padding: "ab" } : { mode: "longest"; padding: string; } ->mode : "longest" ->"longest" : "longest" ->padding : string ->"ab" : "ab" - -const a: [string][] = Iterator.zip([new String("ab")]).toArray(); ->a : [string][] ->Iterator.zip([new String("ab")]).toArray() : [string][] ->Iterator.zip([new String("ab")]).toArray : () => [string][] ->Iterator.zip([new String("ab")]) : IteratorObject<[string], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->[new String("ab")] : [String] ->new String("ab") : String ->String : StringConstructor ->"ab" : "ab" ->toArray : () => [string][] - -const b: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); ->b : { a: string; }[] ->a : string ->Iterator.zipKeyed({ a: new String("ab") }).toArray() : { a: string; }[] ->Iterator.zipKeyed({ a: new String("ab") }).toArray : () => { a: string; }[] ->Iterator.zipKeyed({ a: new String("ab") }) : IteratorObject<{ a: string; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ a: new String("ab") } : { a: String; } ->a : String ->new String("ab") : String ->String : StringConstructor ->"ab" : "ab" ->toArray : () => { a: string; }[] - -const c: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); ->c : (string | undefined)[][] ->Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray() : (string | undefined)[][] ->Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray : () => (string | undefined)[][] ->Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }) : IteratorObject<(string | undefined)[], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->[["a"]] : string[][] ->["a"] : string[] ->"a" : "a" ->{ mode: "longest", padding: new String("ab") } : { mode: "longest"; padding: String; } ->mode : "longest" ->"longest" : "longest" ->padding : String ->new String("ab") : String ->String : StringConstructor ->"ab" : "ab" ->toArray : () => (string | undefined)[][] - -const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); ->d : { a: number; }[] ->Iterator.zipKeyed({ a: [1], b: undefined }).toArray() : { a: number; }[] ->Iterator.zipKeyed({ a: [1], b: undefined }).toArray : () => { a: number; }[] ->Iterator.zipKeyed({ a: [1], b: undefined }) : IteratorObject<{ a: number; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ a: [1], b: undefined } : { a: number[]; b: undefined; } ->a : number[] ->[1] : number[] ->1 : 1 ->b : undefined ->undefined : undefined ->toArray : () => { a: number; }[] - -const e: { a: number; }[] = d; ->e : { a: number; }[] ->a : number ->d : { a: number; }[] - -d[0].b; ->d[0].b : any ->d[0] : { a: number; } ->d : { a: number; }[] ->0 : 0 ->b : any - -const f: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); ->f : never[] ->Iterator.zipKeyed({ a: undefined }).toArray() : never[] ->Iterator.zipKeyed({ a: undefined }).toArray : () => never[] ->Iterator.zipKeyed({ a: undefined }) : IteratorObject ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ a: undefined } : { a: undefined; } ->a : undefined ->undefined : undefined ->toArray : () => never[] - -const g: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); ->g : never[] ->Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray() : never[] ->Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray : () => never[] ->Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }) : IteratorObject ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ a: undefined } : { a: undefined; } ->a : undefined ->undefined : undefined ->{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } ->mode : "longest" ->"longest" : "longest" ->padding : {} ->{} : {} ->toArray : () => never[] - -interface I { - readonly a: Iterable; ->a : Iterable - - readonly b?: Iterator; ->b : Iterator | undefined - - readonly c: Iterable | undefined; ->c : Iterable | undefined - - readonly d?: undefined; ->d : undefined -} -declare const h: I; ->h : I - -const i = Iterator.zipKeyed(h).toArray(); ->i : { a: number; b?: string; c?: boolean; }[] ->Iterator.zipKeyed(h).toArray() : { a: number; b?: string; c?: boolean; }[] ->Iterator.zipKeyed(h).toArray : () => { a: number; b?: string; c?: boolean; }[] ->Iterator.zipKeyed(h) : IteratorObject<{ a: number; b?: string; c?: boolean; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->h : I ->toArray : () => { a: number; b?: string; c?: boolean; }[] - -const j: { a: number; b?: string; c?: boolean; }[] = i; ->j : { a: number; b?: string; c?: boolean; }[] ->a : number ->b : string | undefined ->c : boolean | undefined ->i : { a: number; b?: string; c?: boolean; }[] - -i[0].a = 2; ->i[0].a = 2 : 2 ->i[0].a : number ->i[0] : { a: number; b?: string; c?: boolean; } ->i : { a: number; b?: string; c?: boolean; }[] ->0 : 0 ->a : number ->2 : 2 - -i[0].b = "a"; ->i[0].b = "a" : "a" ->i[0].b : string ->i[0] : { a: number; b?: string; c?: boolean; } ->i : { a: number; b?: string; c?: boolean; }[] ->0 : 0 ->b : string ->"a" : "a" - -i[0].c = true; ->i[0].c = true : true ->i[0].c : boolean ->i[0] : { a: number; b?: string; c?: boolean; } ->i : { a: number; b?: string; c?: boolean; }[] ->0 : 0 ->c : boolean ->true : true - -i[0].d; ->i[0].d : any ->i[0] : { a: number; b?: string; c?: boolean; } ->i : { a: number; b?: string; c?: boolean; }[] ->0 : 0 ->d : any - -const k: { a: number; c: boolean; }[] = i; ->k : { a: number; c: boolean; }[] ->a : number ->c : boolean ->i : { a: number; b?: string; c?: boolean; }[] - -const l: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); ->l : { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] ->a : number | undefined ->b : string | undefined ->c : boolean | undefined ->Iterator.zipKeyed(h, { mode: "longest" }).toArray() : { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] ->Iterator.zipKeyed(h, { mode: "longest" }).toArray : () => { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] ->Iterator.zipKeyed(h, { mode: "longest" }) : IteratorObject<{ a: number | undefined; b?: string | undefined; c?: boolean | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->h : I ->{ mode: "longest" } : { mode: "longest"; } ->mode : "longest" ->"longest" : "longest" ->toArray : () => { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] - -declare const m: { a: Iterable; } | { b: Iterator; }; ->m : { a: Iterable; } | { b: Iterator; } ->a : Iterable ->b : Iterator - -const n: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(m).toArray(); ->n : ({ a: number; } | { b: string; })[] ->a : number ->b : string ->Iterator.zipKeyed(m).toArray() : ({ a: number; } | { b: string; })[] ->Iterator.zipKeyed(m).toArray : () => ({ a: number; } | { b: string; })[] ->Iterator.zipKeyed(m) : IteratorObject<{ a: number; } | { b: string; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->m : { a: Iterable; } | { b: Iterator; } ->toArray : () => ({ a: number; } | { b: string; })[] - -declare const o: { a: Iterable; } | { b: number; }; ->o : { a: Iterable; } | { b: number; } ->a : Iterable ->b : number - -Iterator.zipKeyed(o); ->Iterator.zipKeyed(o) : IteratorObject<{ a: number; } | { b: never; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->o : { a: Iterable; } | { b: number; } - -Iterator.zipKeyed(o, { mode: "longest" }); ->Iterator.zipKeyed(o, { mode: "longest" }) : IteratorObject<{ a: number; } | { b: never; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->o : { a: Iterable; } | { b: number; } ->{ mode: "longest" } : { mode: "longest"; } ->mode : "longest" ->"longest" : "longest" - -Iterator.zipKeyed(o, { mode: "longest", padding: {} }); ->Iterator.zipKeyed(o, { mode: "longest", padding: {} }) : IteratorObject<{ a: number; } | { b: never; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->o : { a: Iterable; } | { b: number; } ->{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } ->mode : "longest" ->"longest" : "longest" ->padding : {} ->{} : {} - -declare const p: { a?: Iterable; } | { b: string; }; ->p : { a?: Iterable; } | { b: string; } ->a : Iterable | undefined ->b : string - -Iterator.zipKeyed(p); ->Iterator.zipKeyed(p) : IteratorObject<{ a?: number; } | { b: never; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->p : { a?: Iterable; } | { b: string; } - -declare const q: { a: Iterable; } | { b: undefined; }; ->q : { a: Iterable; } | { b: undefined; } ->a : Iterable ->b : undefined - -const r: { a: number; }[] = Iterator.zipKeyed(q).toArray(); ->r : { a: number; }[] ->a : number ->Iterator.zipKeyed(q).toArray() : { a: number; }[] ->Iterator.zipKeyed(q).toArray : () => { a: number; }[] ->Iterator.zipKeyed(q) : IteratorObject<{ a: number; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->q : { a: Iterable; } | { b: undefined; } ->toArray : () => { a: number; }[] - -declare const s: unique symbol; ->s : unique symbol - -declare const t: { a: Iterable; [s]?: Iterable; }; ->t : { a: Iterable; [s]?: Iterable; } ->a : Iterable ->[s] : Iterable | undefined ->s : unique symbol - -const u: { a: number; [s]?: string; }[] = Iterator.zipKeyed(t).toArray(); ->u : { a: number; [s]?: string; }[] ->a : number ->[s] : string | undefined ->s : unique symbol ->Iterator.zipKeyed(t).toArray() : { a: number; [s]?: string; }[] ->Iterator.zipKeyed(t).toArray : () => { a: number; [s]?: string; }[] ->Iterator.zipKeyed(t) : IteratorObject<{ a: number; [s]?: string; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->t : { a: Iterable; [s]?: Iterable; } ->toArray : () => { a: number; [s]?: string; }[] - -Iterator.zipKeyed({ a: [1], b: null }); ->Iterator.zipKeyed({ a: [1], b: null }) : IteratorObject<{ a: number; b: never; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ a: [1], b: null } : { a: number[]; b: null; } ->a : number[] ->[1] : number[] ->1 : 1 ->b : null - -Iterator.zipKeyed({ a: [1], b: false }); ->Iterator.zipKeyed({ a: [1], b: false }) : IteratorObject<{ a: number; b: never; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ a: [1], b: false } : { a: number[]; b: boolean; } ->a : number[] ->[1] : number[] ->1 : 1 ->b : boolean ->false : false - -Iterator.zip([undefined]); ->Iterator.zip([undefined]) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->[undefined] : [undefined] ->undefined : undefined - -declare const v: { a?: undefined; }; ->v : { a?: undefined; } ->a : undefined - -const w: never[] = Iterator.zipKeyed(v).toArray(); ->w : never[] ->Iterator.zipKeyed(v).toArray() : never[] ->Iterator.zipKeyed(v).toArray : () => never[] ->Iterator.zipKeyed(v) : IteratorObject ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->v : { a?: undefined; } ->toArray : () => never[] - -const x: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); ->x : { a: number; }[] ->a : number ->Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray() : { a: number; }[] ->Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray : () => { a: number; }[] ->Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }) : IteratorObject<{ a: number; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ a: [1], b: undefined } : { a: number[]; b: undefined; } ->a : number[] ->[1] : number[] ->1 : 1 ->b : undefined ->undefined : undefined ->{ mode: "longest", padding: { a: 0 } } : { mode: "longest"; padding: { a: number; }; } ->mode : "longest" ->"longest" : "longest" ->padding : { a: number; } ->{ a: 0 } : { a: number; } ->a : number ->0 : 0 ->toArray : () => { a: number; }[] - -const y: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); ->y : { a: number | undefined; }[] ->a : number | undefined ->Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray() : { a: number | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray : () => { a: number | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }) : IteratorObject<{ a: number | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ a: [1], b: undefined } : { a: number[]; b: undefined; } ->a : number[] ->[1] : number[] ->1 : 1 ->b : undefined ->undefined : undefined ->{ mode: "longest" } : { mode: "longest"; } ->mode : "longest" ->"longest" : "longest" ->toArray : () => { a: number | undefined; }[] - -function f1(a: Iterable) { ->f1 : (a: Iterable) => { b: { a: T; }[]; c: [T][]; } ->a : Iterable - - const b: { a: T; }[] = Iterator.zipKeyed({ a }).toArray(); ->b : { a: T; }[] ->a : T ->Iterator.zipKeyed({ a }).toArray() : { a: T; }[] ->Iterator.zipKeyed({ a }).toArray : () => { a: T; }[] ->Iterator.zipKeyed({ a }) : IteratorObject<{ a: T; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K]; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K]; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K]; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K]; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K]; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K]; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ a } : { a: Iterable; } ->a : Iterable ->toArray : () => { a: T; }[] - - const c: [T][] = Iterator.zip([a]).toArray(); ->c : [T][] ->Iterator.zip([a]).toArray() : [T][] ->Iterator.zip([a]).toArray : () => [T][] ->Iterator.zip([a]) : IteratorObject<[T], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T_1, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T_1, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T_1, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T_1 extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T_1 extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T_1, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T_1, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T_1, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T_1 extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T_1 extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->[a] : [Iterable] ->a : Iterable ->toArray : () => [T][] - - return { b, c }; ->{ b, c } : { b: { a: T; }[]; c: [T][]; } ->b : { a: T; }[] ->c : [T][] -} - diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=false).errors.txt b/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=false).errors.txt deleted file mode 100644 index 4ba9821668036..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=false).errors.txt +++ /dev/null @@ -1,215 +0,0 @@ -iteratorZipPadding.ts(4,7): error TS2322: Type '[number, ...(number | undefined)[]][]' is not assignable to type 'number[][]'. - Type '[number, ...(number | undefined)[]]' is not assignable to type 'number[]'. - Type 'number | undefined' is not assignable to type 'number'. - Type 'undefined' is not assignable to type 'number'. -iteratorZipPadding.ts(9,7): error TS2322: Type 'IteratorZipResult<{ [x: string]: Iterable; } & {}, undefined, {}>[]' is not assignable to type 'Record[]'. - Type 'IteratorZipResult<{ [x: string]: Iterable; } & {}, undefined, {}>' is not assignable to type 'Record'. - 'string' index signatures are incompatible. - Type 'number | undefined' is not assignable to type 'number'. - Type 'undefined' is not assignable to type 'number'. -iteratorZipPadding.ts(14,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record>[]' is not assignable to type '{ a: number; b: number; }[]'. - Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record>' is not assignable to type '{ a: number; b: number; }'. - Types of property 'a' are incompatible. - Type 'number | undefined' is not assignable to type 'number'. - Type 'undefined' is not assignable to type 'number'. -iteratorZipPadding.ts(23,7): error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. - Type '[number, string | undefined]' is not assignable to type '[number, string]'. - Type at position 1 in source is not compatible with type at position 1 in target. - Type 'string | undefined' is not assignable to type 'string'. - Type 'undefined' is not assignable to type 'string'. -iteratorZipPadding.ts(26,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; }>[]' is not assignable to type '{ a: number; b: string; }[]'. - Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; b: string; }'. - Types of property 'b' are incompatible. - Type 'string | undefined' is not assignable to type 'string'. - Type 'undefined' is not assignable to type 'string'. -iteratorZipPadding.ts(32,7): error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. - Type '[number, string | undefined]' is not assignable to type '[number, string]'. - Type at position 1 in source is not compatible with type at position 1 in target. - Type 'string | undefined' is not assignable to type 'string'. - Type 'undefined' is not assignable to type 'string'. -iteratorZipPadding.ts(36,7): error TS2322: Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>[]' is not assignable to type 'number[][]'. - Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>' is not assignable to type 'number[]'. - Type '[number, number | undefined]' is not assignable to type 'number[]'. - Type 'number | undefined' is not assignable to type 'number'. - Type 'undefined' is not assignable to type 'number'. -iteratorZipPadding.ts(39,7): error TS2322: Type '(IteratorZipResult<{ a: Iterable; } & {}, undefined, { a: number; }> | IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>)[]' is not assignable to type '({ a: number; } | { b: string; })[]'. - Type 'IteratorZipResult<{ a: Iterable; } & {}, undefined, { a: number; }> | IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; } | { b: string; }'. - Type 'IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; } | { b: string; }'. - Type 'IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ b: string; }'. - Types of property 'b' are incompatible. - Type 'string | undefined' is not assignable to type 'string'. - Type 'undefined' is not assignable to type 'string'. -iteratorZipPadding.ts(43,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; } | { b: string; }>[]' is not assignable to type '{ a: number; b: string; }[]'. - Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; } | { b: string; }>' is not assignable to type '{ a: number; b: string; }'. - Types of property 'a' are incompatible. - Type 'number | undefined' is not assignable to type 'number'. - Type 'undefined' is not assignable to type 'number'. -iteratorZipPadding.ts(46,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, { a: undefined; b: number; }>[]' is not assignable to type '{ a: number; b: number; }[]'. - Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, { a: undefined; b: number; }>' is not assignable to type '{ a: number; b: number; }'. - Types of property 'a' are incompatible. - Type 'number | undefined' is not assignable to type 'number'. - Type 'undefined' is not assignable to type 'number'. -iteratorZipPadding.ts(50,7): error TS2322: Type 'IteratorZipResult<{ [x: `a${string}`]: Iterable; } & {}, undefined, {}>[]' is not assignable to type '{ [x: `a${string}`]: number; }[]'. - Type 'IteratorZipResult<{ [x: `a${string}`]: Iterable; } & {}, undefined, {}>' is not assignable to type '{ [x: `a${string}`]: number; }'. - '`a${string}`' index signatures are incompatible. - Type 'number | undefined' is not assignable to type 'number'. - Type 'undefined' is not assignable to type 'number'. -iteratorZipPadding.ts(58,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record & { a: number; }>[]' is not assignable to type '{ a: number; b: number; }[]'. - Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record & { a: number; }>' is not assignable to type '{ a: number; b: number; }'. - Types of property 'b' are incompatible. - Type 'number | undefined' is not assignable to type 'number'. - Type 'undefined' is not assignable to type 'number'. -iteratorZipPadding.ts(63,7): error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. - Type '[number, string | undefined]' is not assignable to type '[number, string]'. - Type at position 1 in source is not compatible with type at position 1 in target. - Type 'string | undefined' is not assignable to type 'string'. - Type 'undefined' is not assignable to type 'string'. - - -==== iteratorZipPadding.ts (13 errors) ==== - const a: [Iterable, ...Iterable[]] = [[1, 2], [3]]; - const b = Iterator.zip(a, { mode: "longest", padding: [0] }).toArray(); - const c: (number | undefined)[][] = b; - const d: number[][] = b; - ~ -!!! error TS2322: Type '[number, ...(number | undefined)[]][]' is not assignable to type 'number[][]'. -!!! error TS2322: Type '[number, ...(number | undefined)[]]' is not assignable to type 'number[]'. -!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. -!!! error TS2322: Type 'undefined' is not assignable to type 'number'. - - const e: Record> = { a: [1], b: [2, 3] }; - const f = Iterator.zipKeyed(e, { mode: "longest", padding: {} }).toArray(); - const g: Record[] = f; - const h: Record[] = f; - ~ -!!! error TS2322: Type 'IteratorZipResult<{ [x: string]: Iterable; } & {}, undefined, {}>[]' is not assignable to type 'Record[]'. -!!! error TS2322: Type 'IteratorZipResult<{ [x: string]: Iterable; } & {}, undefined, {}>' is not assignable to type 'Record'. -!!! error TS2322: 'string' index signatures are incompatible. -!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. -!!! error TS2322: Type 'undefined' is not assignable to type 'number'. - - declare const i: Record; - const j = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: i }).toArray(); - const k: { a: number | undefined; b: number | undefined; }[] = j; - const l: { a: number; b: number; }[] = j; - ~ -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record>[]' is not assignable to type '{ a: number; b: number; }[]'. -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record>' is not assignable to type '{ a: number; b: number; }'. -!!! error TS2322: Types of property 'a' are incompatible. -!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. -!!! error TS2322: Type 'undefined' is not assignable to type 'number'. - - const m = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); - const n: [number, string][] = m; - const o = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); - const p: { a: number; b: string; }[] = o; - - const q = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); - const r: [number | undefined, string | undefined][] = q; - const s: [number, string][] = q; - ~ -!!! error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. -!!! error TS2322: Type '[number, string | undefined]' is not assignable to type '[number, string]'. -!!! error TS2322: Type at position 1 in source is not compatible with type at position 1 in target. -!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. -!!! error TS2322: Type 'undefined' is not assignable to type 'string'. - const t = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); - const u: { a: number | undefined; b: string | undefined; }[] = t; - const v: { a: number; b: string; }[] = t; - ~ -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; }>[]' is not assignable to type '{ a: number; b: string; }[]'. -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; b: string; }'. -!!! error TS2322: Types of property 'b' are incompatible. -!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. -!!! error TS2322: Type 'undefined' is not assignable to type 'string'. - - declare const w: readonly [number, string]; - const x: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: w }).toArray(); - declare const y: [number, string?]; - const z = Iterator.zip([[1], ["a"]], { mode: "longest", padding: y }).toArray(); - const a1: [number, string][] = z; - ~~ -!!! error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. -!!! error TS2322: Type '[number, string | undefined]' is not assignable to type '[number, string]'. -!!! error TS2322: Type at position 1 in source is not compatible with type at position 1 in target. -!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. -!!! error TS2322: Type 'undefined' is not assignable to type 'string'. - - declare const b1: [Iterable] | [Iterable, Iterable]; - const c1 = Iterator.zip(b1, { mode: "longest", padding: [0] }).toArray(); - const d1: number[][] = c1; - ~~ -!!! error TS2322: Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>[]' is not assignable to type 'number[][]'. -!!! error TS2322: Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>' is not assignable to type 'number[]'. -!!! error TS2322: Type '[number, number | undefined]' is not assignable to type 'number[]'. -!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. -!!! error TS2322: Type 'undefined' is not assignable to type 'number'. - declare const e1: { a: Iterable; } | { b: Iterable; }; - const f1 = Iterator.zipKeyed(e1, { mode: "longest", padding: { a: 0 } }).toArray(); - const g1: ({ a: number; } | { b: string; })[] = f1; - ~~ -!!! error TS2322: Type '(IteratorZipResult<{ a: Iterable; } & {}, undefined, { a: number; }> | IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>)[]' is not assignable to type '({ a: number; } | { b: string; })[]'. -!!! error TS2322: Type 'IteratorZipResult<{ a: Iterable; } & {}, undefined, { a: number; }> | IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; } | { b: string; }'. -!!! error TS2322: Type 'IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; } | { b: string; }'. -!!! error TS2322: Type 'IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ b: string; }'. -!!! error TS2322: Types of property 'b' are incompatible. -!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. -!!! error TS2322: Type 'undefined' is not assignable to type 'string'. - - declare const h1: { a: number; } | { b: string; }; - const i1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: h1 }).toArray(); - const j1: { a: number; b: string; }[] = i1; - ~~ -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; } | { b: string; }>[]' is not assignable to type '{ a: number; b: string; }[]'. -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; } | { b: string; }>' is not assignable to type '{ a: number; b: string; }'. -!!! error TS2322: Types of property 'a' are incompatible. -!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. -!!! error TS2322: Type 'undefined' is not assignable to type 'number'. - - const k1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); - const l1: { a: number; b: number; }[] = k1; - ~~ -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, { a: undefined; b: number; }>[]' is not assignable to type '{ a: number; b: number; }[]'. -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, { a: undefined; b: number; }>' is not assignable to type '{ a: number; b: number; }'. -!!! error TS2322: Types of property 'a' are incompatible. -!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. -!!! error TS2322: Type 'undefined' is not assignable to type 'number'. - - declare const m1: { [K in `a${string}`]: Iterable; }; - const n1 = Iterator.zipKeyed(m1, { mode: "longest", padding: {} }).toArray(); - const o1: { [K in `a${string}`]: number; }[] = n1; - ~~ -!!! error TS2322: Type 'IteratorZipResult<{ [x: `a${string}`]: Iterable; } & {}, undefined, {}>[]' is not assignable to type '{ [x: `a${string}`]: number; }[]'. -!!! error TS2322: Type 'IteratorZipResult<{ [x: `a${string}`]: Iterable; } & {}, undefined, {}>' is not assignable to type '{ [x: `a${string}`]: number; }'. -!!! error TS2322: '`a${string}`' index signatures are incompatible. -!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. -!!! error TS2322: Type 'undefined' is not assignable to type 'number'. - - declare const p1: unique symbol; - const q1: { [p1]: number; }[] = Iterator.zipKeyed({ [p1]: [1] }, { mode: "longest", padding: { [p1]: 0 } }).toArray(); - - declare const r1: Record & { a: number; }; - const s1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: r1 }).toArray(); - const t1: { a: number; b: number | undefined; }[] = s1; - const u1: { a: number; b: number; }[] = s1; - ~~ -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record & { a: number; }>[]' is not assignable to type '{ a: number; b: number; }[]'. -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record & { a: number; }>' is not assignable to type '{ a: number; b: number; }'. -!!! error TS2322: Types of property 'b' are incompatible. -!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. -!!! error TS2322: Type 'undefined' is not assignable to type 'number'. - - declare const v1: [number] | [number, string]; - const w1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: v1 }).toArray(); - const x1: [number, string | undefined][] = w1; - const y1: [number, string][] = w1; - ~~ -!!! error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. -!!! error TS2322: Type '[number, string | undefined]' is not assignable to type '[number, string]'. -!!! error TS2322: Type at position 1 in source is not compatible with type at position 1 in target. -!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. -!!! error TS2322: Type 'undefined' is not assignable to type 'string'. - - const z1: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); - const a2: { a: number | undefined; b: number; }[] = k1; - \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=false).js b/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=false).js deleted file mode 100644 index 408ebf1bc1fac..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=false).js +++ /dev/null @@ -1,248 +0,0 @@ -//// [tests/cases/compiler/iteratorZipPadding.ts] //// - -//// [iteratorZipPadding.ts] -const a: [Iterable, ...Iterable[]] = [[1, 2], [3]]; -const b = Iterator.zip(a, { mode: "longest", padding: [0] }).toArray(); -const c: (number | undefined)[][] = b; -const d: number[][] = b; - -const e: Record> = { a: [1], b: [2, 3] }; -const f = Iterator.zipKeyed(e, { mode: "longest", padding: {} }).toArray(); -const g: Record[] = f; -const h: Record[] = f; - -declare const i: Record; -const j = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: i }).toArray(); -const k: { a: number | undefined; b: number | undefined; }[] = j; -const l: { a: number; b: number; }[] = j; - -const m = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); -const n: [number, string][] = m; -const o = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); -const p: { a: number; b: string; }[] = o; - -const q = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); -const r: [number | undefined, string | undefined][] = q; -const s: [number, string][] = q; -const t = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); -const u: { a: number | undefined; b: string | undefined; }[] = t; -const v: { a: number; b: string; }[] = t; - -declare const w: readonly [number, string]; -const x: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: w }).toArray(); -declare const y: [number, string?]; -const z = Iterator.zip([[1], ["a"]], { mode: "longest", padding: y }).toArray(); -const a1: [number, string][] = z; - -declare const b1: [Iterable] | [Iterable, Iterable]; -const c1 = Iterator.zip(b1, { mode: "longest", padding: [0] }).toArray(); -const d1: number[][] = c1; -declare const e1: { a: Iterable; } | { b: Iterable; }; -const f1 = Iterator.zipKeyed(e1, { mode: "longest", padding: { a: 0 } }).toArray(); -const g1: ({ a: number; } | { b: string; })[] = f1; - -declare const h1: { a: number; } | { b: string; }; -const i1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: h1 }).toArray(); -const j1: { a: number; b: string; }[] = i1; - -const k1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); -const l1: { a: number; b: number; }[] = k1; - -declare const m1: { [K in `a${string}`]: Iterable; }; -const n1 = Iterator.zipKeyed(m1, { mode: "longest", padding: {} }).toArray(); -const o1: { [K in `a${string}`]: number; }[] = n1; - -declare const p1: unique symbol; -const q1: { [p1]: number; }[] = Iterator.zipKeyed({ [p1]: [1] }, { mode: "longest", padding: { [p1]: 0 } }).toArray(); - -declare const r1: Record & { a: number; }; -const s1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: r1 }).toArray(); -const t1: { a: number; b: number | undefined; }[] = s1; -const u1: { a: number; b: number; }[] = s1; - -declare const v1: [number] | [number, string]; -const w1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: v1 }).toArray(); -const x1: [number, string | undefined][] = w1; -const y1: [number, string][] = w1; - -const z1: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); -const a2: { a: number | undefined; b: number; }[] = k1; - - -//// [iteratorZipPadding.js] -"use strict"; -const a = [[1, 2], [3]]; -const b = Iterator.zip(a, { mode: "longest", padding: [0] }).toArray(); -const c = b; -const d = b; -const e = { a: [1], b: [2, 3] }; -const f = Iterator.zipKeyed(e, { mode: "longest", padding: {} }).toArray(); -const g = f; -const h = f; -const j = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: i }).toArray(); -const k = j; -const l = j; -const m = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); -const n = m; -const o = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); -const p = o; -const q = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); -const r = q; -const s = q; -const t = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); -const u = t; -const v = t; -const x = Iterator.zip([[1], ["a"]], { mode: "longest", padding: w }).toArray(); -const z = Iterator.zip([[1], ["a"]], { mode: "longest", padding: y }).toArray(); -const a1 = z; -const c1 = Iterator.zip(b1, { mode: "longest", padding: [0] }).toArray(); -const d1 = c1; -const f1 = Iterator.zipKeyed(e1, { mode: "longest", padding: { a: 0 } }).toArray(); -const g1 = f1; -const i1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: h1 }).toArray(); -const j1 = i1; -const k1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); -const l1 = k1; -const n1 = Iterator.zipKeyed(m1, { mode: "longest", padding: {} }).toArray(); -const o1 = n1; -const q1 = Iterator.zipKeyed({ [p1]: [1] }, { mode: "longest", padding: { [p1]: 0 } }).toArray(); -const s1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: r1 }).toArray(); -const t1 = s1; -const u1 = s1; -const w1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: v1 }).toArray(); -const x1 = w1; -const y1 = w1; -const z1 = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); -const a2 = k1; - - -//// [iteratorZipPadding.d.ts] -declare const a: [Iterable, ...Iterable[]]; -declare const b: [number, ...(number | undefined)[]][]; -declare const c: (number | undefined)[][]; -declare const d: number[][]; -declare const e: Record>; -declare const f: { - [x: string]: number | undefined; -}[]; -declare const g: Record[]; -declare const h: Record[]; -declare const i: Record; -declare const j: { - a: number | undefined; - b: number | undefined; -}[]; -declare const k: { - a: number | undefined; - b: number | undefined; -}[]; -declare const l: { - a: number; - b: number; -}[]; -declare const m: [number, string][]; -declare const n: [number, string][]; -declare const o: { - a: number; - b: string; -}[]; -declare const p: { - a: number; - b: string; -}[]; -declare const q: [number, string | undefined][]; -declare const r: [number | undefined, string | undefined][]; -declare const s: [number, string][]; -declare const t: { - a: number; - b: string | undefined; -}[]; -declare const u: { - a: number | undefined; - b: string | undefined; -}[]; -declare const v: { - a: number; - b: string; -}[]; -declare const w: readonly [number, string]; -declare const x: [number, string][]; -declare const y: [number, string?]; -declare const z: [number, string | undefined][]; -declare const a1: [number, string][]; -declare const b1: [Iterable] | [Iterable, Iterable]; -declare const c1: ([number] | [number, number | undefined])[]; -declare const d1: number[][]; -declare const e1: { - a: Iterable; -} | { - b: Iterable; -}; -declare const f1: ({ - a: number; -} | { - b: string | undefined; -})[]; -declare const g1: ({ - a: number; -} | { - b: string; -})[]; -declare const h1: { - a: number; -} | { - b: string; -}; -declare const i1: { - a: number | undefined; - b: string | undefined; -}[]; -declare const j1: { - a: number; - b: string; -}[]; -declare const k1: { - a: number | undefined; - b: number; -}[]; -declare const l1: { - a: number; - b: number; -}[]; -declare const m1: { - [K in `a${string}`]: Iterable; -}; -declare const n1: { - [x: `a${string}`]: number | undefined; -}[]; -declare const o1: { - [K in `a${string}`]: number; -}[]; -declare const p1: unique symbol; -declare const q1: { - [p1]: number; -}[]; -declare const r1: Record & { - a: number; -}; -declare const s1: { - a: number; - b: number | undefined; -}[]; -declare const t1: { - a: number; - b: number | undefined; -}[]; -declare const u1: { - a: number; - b: number; -}[]; -declare const v1: [number] | [number, string]; -declare const w1: [number, string | undefined][]; -declare const x1: [number, string | undefined][]; -declare const y1: [number, string][]; -declare const z1: [number | undefined, number][]; -declare const a2: { - a: number | undefined; - b: number; -}[]; diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=false).symbols b/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=false).symbols deleted file mode 100644 index 7284c5da3fbf8..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=false).symbols +++ /dev/null @@ -1,393 +0,0 @@ -//// [tests/cases/compiler/iteratorZipPadding.ts] //// - -=== iteratorZipPadding.ts === -const a: [Iterable, ...Iterable[]] = [[1, 2], [3]]; ->a : Symbol(a, Decl(iteratorZipPadding.ts, 0, 5)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) - -const b = Iterator.zip(a, { mode: "longest", padding: [0] }).toArray(); ->b : Symbol(b, Decl(iteratorZipPadding.ts, 1, 5)) ->Iterator.zip(a, { mode: "longest", padding: [0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 0, 5)) ->mode : Symbol(mode, Decl(iteratorZipPadding.ts, 1, 27)) ->padding : Symbol(padding, Decl(iteratorZipPadding.ts, 1, 44)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const c: (number | undefined)[][] = b; ->c : Symbol(c, Decl(iteratorZipPadding.ts, 2, 5)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 1, 5)) - -const d: number[][] = b; ->d : Symbol(d, Decl(iteratorZipPadding.ts, 3, 5)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 1, 5)) - -const e: Record> = { a: [1], b: [2, 3] }; ->e : Symbol(e, Decl(iteratorZipPadding.ts, 5, 5)) ->Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 5, 45)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 5, 53)) - -const f = Iterator.zipKeyed(e, { mode: "longest", padding: {} }).toArray(); ->f : Symbol(f, Decl(iteratorZipPadding.ts, 6, 5)) ->Iterator.zipKeyed(e, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->e : Symbol(e, Decl(iteratorZipPadding.ts, 5, 5)) ->mode : Symbol(mode, Decl(iteratorZipPadding.ts, 6, 32)) ->padding : Symbol(padding, Decl(iteratorZipPadding.ts, 6, 49)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const g: Record[] = f; ->g : Symbol(g, Decl(iteratorZipPadding.ts, 7, 5)) ->Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) ->f : Symbol(f, Decl(iteratorZipPadding.ts, 6, 5)) - -const h: Record[] = f; ->h : Symbol(h, Decl(iteratorZipPadding.ts, 8, 5)) ->Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) ->f : Symbol(f, Decl(iteratorZipPadding.ts, 6, 5)) - -declare const i: Record; ->i : Symbol(i, Decl(iteratorZipPadding.ts, 10, 13)) ->Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) - -const j = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: i }).toArray(); ->j : Symbol(j, Decl(iteratorZipPadding.ts, 11, 5)) ->Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: i }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 11, 29)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 11, 37)) ->mode : Symbol(mode, Decl(iteratorZipPadding.ts, 11, 52)) ->padding : Symbol(padding, Decl(iteratorZipPadding.ts, 11, 69)) ->i : Symbol(i, Decl(iteratorZipPadding.ts, 10, 13)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const k: { a: number | undefined; b: number | undefined; }[] = j; ->k : Symbol(k, Decl(iteratorZipPadding.ts, 12, 5)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 12, 10)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 12, 33)) ->j : Symbol(j, Decl(iteratorZipPadding.ts, 11, 5)) - -const l: { a: number; b: number; }[] = j; ->l : Symbol(l, Decl(iteratorZipPadding.ts, 13, 5)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 13, 10)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 13, 21)) ->j : Symbol(j, Decl(iteratorZipPadding.ts, 11, 5)) - -const m = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); ->m : Symbol(m, Decl(iteratorZipPadding.ts, 15, 5)) ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZipPadding.ts, 15, 38)) ->padding : Symbol(padding, Decl(iteratorZipPadding.ts, 15, 55)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const n: [number, string][] = m; ->n : Symbol(n, Decl(iteratorZipPadding.ts, 16, 5)) ->m : Symbol(m, Decl(iteratorZipPadding.ts, 15, 5)) - -const o = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); ->o : Symbol(o, Decl(iteratorZipPadding.ts, 17, 5)) ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 17, 29)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 17, 37)) ->mode : Symbol(mode, Decl(iteratorZipPadding.ts, 17, 51)) ->padding : Symbol(padding, Decl(iteratorZipPadding.ts, 17, 68)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 17, 79)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 17, 85)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const p: { a: number; b: string; }[] = o; ->p : Symbol(p, Decl(iteratorZipPadding.ts, 18, 5)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 18, 10)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 18, 21)) ->o : Symbol(o, Decl(iteratorZipPadding.ts, 17, 5)) - -const q = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); ->q : Symbol(q, Decl(iteratorZipPadding.ts, 20, 5)) ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZipPadding.ts, 20, 38)) ->padding : Symbol(padding, Decl(iteratorZipPadding.ts, 20, 55)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const r: [number | undefined, string | undefined][] = q; ->r : Symbol(r, Decl(iteratorZipPadding.ts, 21, 5)) ->q : Symbol(q, Decl(iteratorZipPadding.ts, 20, 5)) - -const s: [number, string][] = q; ->s : Symbol(s, Decl(iteratorZipPadding.ts, 22, 5)) ->q : Symbol(q, Decl(iteratorZipPadding.ts, 20, 5)) - -const t = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); ->t : Symbol(t, Decl(iteratorZipPadding.ts, 23, 5)) ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 23, 29)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 23, 37)) ->mode : Symbol(mode, Decl(iteratorZipPadding.ts, 23, 51)) ->padding : Symbol(padding, Decl(iteratorZipPadding.ts, 23, 68)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 23, 79)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const u: { a: number | undefined; b: string | undefined; }[] = t; ->u : Symbol(u, Decl(iteratorZipPadding.ts, 24, 5)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 24, 10)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 24, 33)) ->t : Symbol(t, Decl(iteratorZipPadding.ts, 23, 5)) - -const v: { a: number; b: string; }[] = t; ->v : Symbol(v, Decl(iteratorZipPadding.ts, 25, 5)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 25, 10)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 25, 21)) ->t : Symbol(t, Decl(iteratorZipPadding.ts, 23, 5)) - -declare const w: readonly [number, string]; ->w : Symbol(w, Decl(iteratorZipPadding.ts, 27, 13)) - -const x: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: w }).toArray(); ->x : Symbol(x, Decl(iteratorZipPadding.ts, 28, 5)) ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: w }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZipPadding.ts, 28, 58)) ->padding : Symbol(padding, Decl(iteratorZipPadding.ts, 28, 75)) ->w : Symbol(w, Decl(iteratorZipPadding.ts, 27, 13)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -declare const y: [number, string?]; ->y : Symbol(y, Decl(iteratorZipPadding.ts, 29, 13)) - -const z = Iterator.zip([[1], ["a"]], { mode: "longest", padding: y }).toArray(); ->z : Symbol(z, Decl(iteratorZipPadding.ts, 30, 5)) ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: y }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZipPadding.ts, 30, 38)) ->padding : Symbol(padding, Decl(iteratorZipPadding.ts, 30, 55)) ->y : Symbol(y, Decl(iteratorZipPadding.ts, 29, 13)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const a1: [number, string][] = z; ->a1 : Symbol(a1, Decl(iteratorZipPadding.ts, 31, 5)) ->z : Symbol(z, Decl(iteratorZipPadding.ts, 30, 5)) - -declare const b1: [Iterable] | [Iterable, Iterable]; ->b1 : Symbol(b1, Decl(iteratorZipPadding.ts, 33, 13)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) - -const c1 = Iterator.zip(b1, { mode: "longest", padding: [0] }).toArray(); ->c1 : Symbol(c1, Decl(iteratorZipPadding.ts, 34, 5)) ->Iterator.zip(b1, { mode: "longest", padding: [0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->b1 : Symbol(b1, Decl(iteratorZipPadding.ts, 33, 13)) ->mode : Symbol(mode, Decl(iteratorZipPadding.ts, 34, 29)) ->padding : Symbol(padding, Decl(iteratorZipPadding.ts, 34, 46)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const d1: number[][] = c1; ->d1 : Symbol(d1, Decl(iteratorZipPadding.ts, 35, 5)) ->c1 : Symbol(c1, Decl(iteratorZipPadding.ts, 34, 5)) - -declare const e1: { a: Iterable; } | { b: Iterable; }; ->e1 : Symbol(e1, Decl(iteratorZipPadding.ts, 36, 13)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 36, 19)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 36, 46)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) - -const f1 = Iterator.zipKeyed(e1, { mode: "longest", padding: { a: 0 } }).toArray(); ->f1 : Symbol(f1, Decl(iteratorZipPadding.ts, 37, 5)) ->Iterator.zipKeyed(e1, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->e1 : Symbol(e1, Decl(iteratorZipPadding.ts, 36, 13)) ->mode : Symbol(mode, Decl(iteratorZipPadding.ts, 37, 34)) ->padding : Symbol(padding, Decl(iteratorZipPadding.ts, 37, 51)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 37, 62)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const g1: ({ a: number; } | { b: string; })[] = f1; ->g1 : Symbol(g1, Decl(iteratorZipPadding.ts, 38, 5)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 38, 12)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 38, 29)) ->f1 : Symbol(f1, Decl(iteratorZipPadding.ts, 37, 5)) - -declare const h1: { a: number; } | { b: string; }; ->h1 : Symbol(h1, Decl(iteratorZipPadding.ts, 40, 13)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 40, 19)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 40, 36)) - -const i1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: h1 }).toArray(); ->i1 : Symbol(i1, Decl(iteratorZipPadding.ts, 41, 5)) ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: h1 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 41, 30)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 41, 38)) ->mode : Symbol(mode, Decl(iteratorZipPadding.ts, 41, 52)) ->padding : Symbol(padding, Decl(iteratorZipPadding.ts, 41, 69)) ->h1 : Symbol(h1, Decl(iteratorZipPadding.ts, 40, 13)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const j1: { a: number; b: string; }[] = i1; ->j1 : Symbol(j1, Decl(iteratorZipPadding.ts, 42, 5)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 42, 11)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 42, 22)) ->i1 : Symbol(i1, Decl(iteratorZipPadding.ts, 41, 5)) - -const k1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); ->k1 : Symbol(k1, Decl(iteratorZipPadding.ts, 44, 5)) ->Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 44, 30)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 44, 38)) ->mode : Symbol(mode, Decl(iteratorZipPadding.ts, 44, 50)) ->padding : Symbol(padding, Decl(iteratorZipPadding.ts, 44, 67)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 44, 78)) ->undefined : Symbol(undefined) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 44, 92)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const l1: { a: number; b: number; }[] = k1; ->l1 : Symbol(l1, Decl(iteratorZipPadding.ts, 45, 5)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 45, 11)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 45, 22)) ->k1 : Symbol(k1, Decl(iteratorZipPadding.ts, 44, 5)) - -declare const m1: { [K in `a${string}`]: Iterable; }; ->m1 : Symbol(m1, Decl(iteratorZipPadding.ts, 47, 13)) ->K : Symbol(K, Decl(iteratorZipPadding.ts, 47, 21)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) - -const n1 = Iterator.zipKeyed(m1, { mode: "longest", padding: {} }).toArray(); ->n1 : Symbol(n1, Decl(iteratorZipPadding.ts, 48, 5)) ->Iterator.zipKeyed(m1, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->m1 : Symbol(m1, Decl(iteratorZipPadding.ts, 47, 13)) ->mode : Symbol(mode, Decl(iteratorZipPadding.ts, 48, 34)) ->padding : Symbol(padding, Decl(iteratorZipPadding.ts, 48, 51)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const o1: { [K in `a${string}`]: number; }[] = n1; ->o1 : Symbol(o1, Decl(iteratorZipPadding.ts, 49, 5)) ->K : Symbol(K, Decl(iteratorZipPadding.ts, 49, 13)) ->n1 : Symbol(n1, Decl(iteratorZipPadding.ts, 48, 5)) - -declare const p1: unique symbol; ->p1 : Symbol(p1, Decl(iteratorZipPadding.ts, 51, 13)) - -const q1: { [p1]: number; }[] = Iterator.zipKeyed({ [p1]: [1] }, { mode: "longest", padding: { [p1]: 0 } }).toArray(); ->q1 : Symbol(q1, Decl(iteratorZipPadding.ts, 52, 5)) ->[p1] : Symbol([p1], Decl(iteratorZipPadding.ts, 52, 11)) ->p1 : Symbol(p1, Decl(iteratorZipPadding.ts, 51, 13)) ->Iterator.zipKeyed({ [p1]: [1] }, { mode: "longest", padding: { [p1]: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->[p1] : Symbol([p1], Decl(iteratorZipPadding.ts, 52, 51)) ->p1 : Symbol(p1, Decl(iteratorZipPadding.ts, 51, 13)) ->mode : Symbol(mode, Decl(iteratorZipPadding.ts, 52, 66)) ->padding : Symbol(padding, Decl(iteratorZipPadding.ts, 52, 83)) ->[p1] : Symbol([p1], Decl(iteratorZipPadding.ts, 52, 94)) ->p1 : Symbol(p1, Decl(iteratorZipPadding.ts, 51, 13)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -declare const r1: Record & { a: number; }; ->r1 : Symbol(r1, Decl(iteratorZipPadding.ts, 54, 13)) ->Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 54, 44)) - -const s1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: r1 }).toArray(); ->s1 : Symbol(s1, Decl(iteratorZipPadding.ts, 55, 5)) ->Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: r1 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 55, 30)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 55, 38)) ->mode : Symbol(mode, Decl(iteratorZipPadding.ts, 55, 50)) ->padding : Symbol(padding, Decl(iteratorZipPadding.ts, 55, 67)) ->r1 : Symbol(r1, Decl(iteratorZipPadding.ts, 54, 13)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const t1: { a: number; b: number | undefined; }[] = s1; ->t1 : Symbol(t1, Decl(iteratorZipPadding.ts, 56, 5)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 56, 11)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 56, 22)) ->s1 : Symbol(s1, Decl(iteratorZipPadding.ts, 55, 5)) - -const u1: { a: number; b: number; }[] = s1; ->u1 : Symbol(u1, Decl(iteratorZipPadding.ts, 57, 5)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 57, 11)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 57, 22)) ->s1 : Symbol(s1, Decl(iteratorZipPadding.ts, 55, 5)) - -declare const v1: [number] | [number, string]; ->v1 : Symbol(v1, Decl(iteratorZipPadding.ts, 59, 13)) - -const w1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: v1 }).toArray(); ->w1 : Symbol(w1, Decl(iteratorZipPadding.ts, 60, 5)) ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: v1 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZipPadding.ts, 60, 39)) ->padding : Symbol(padding, Decl(iteratorZipPadding.ts, 60, 56)) ->v1 : Symbol(v1, Decl(iteratorZipPadding.ts, 59, 13)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const x1: [number, string | undefined][] = w1; ->x1 : Symbol(x1, Decl(iteratorZipPadding.ts, 61, 5)) ->w1 : Symbol(w1, Decl(iteratorZipPadding.ts, 60, 5)) - -const y1: [number, string][] = w1; ->y1 : Symbol(y1, Decl(iteratorZipPadding.ts, 62, 5)) ->w1 : Symbol(w1, Decl(iteratorZipPadding.ts, 60, 5)) - -const z1: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); ->z1 : Symbol(z1, Decl(iteratorZipPadding.ts, 64, 5)) ->Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZipPadding.ts, 64, 69)) ->padding : Symbol(padding, Decl(iteratorZipPadding.ts, 64, 86)) ->undefined : Symbol(undefined) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const a2: { a: number | undefined; b: number; }[] = k1; ->a2 : Symbol(a2, Decl(iteratorZipPadding.ts, 65, 5)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 65, 11)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 65, 34)) ->k1 : Symbol(k1, Decl(iteratorZipPadding.ts, 44, 5)) - diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=false).types b/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=false).types deleted file mode 100644 index b67a86444b7f1..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=false).types +++ /dev/null @@ -1,549 +0,0 @@ -//// [tests/cases/compiler/iteratorZipPadding.ts] //// - -=== iteratorZipPadding.ts === -const a: [Iterable, ...Iterable[]] = [[1, 2], [3]]; ->a : [Iterable, ...Iterable[]] ->[[1, 2], [3]] : [number[], number[]] ->[1, 2] : number[] ->1 : 1 ->2 : 2 ->[3] : number[] ->3 : 3 - -const b = Iterator.zip(a, { mode: "longest", padding: [0] }).toArray(); ->b : [number, ...(number | undefined)[]][] ->Iterator.zip(a, { mode: "longest", padding: [0] }).toArray() : [number, ...(number | undefined)[]][] ->Iterator.zip(a, { mode: "longest", padding: [0] }).toArray : () => [number, ...(number | undefined)[]][] ->Iterator.zip(a, { mode: "longest", padding: [0] }) : IteratorObject<[number, ...(number | undefined)[]], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->a : [Iterable, ...Iterable[]] ->{ mode: "longest", padding: [0] } : { mode: "longest"; padding: [number]; } ->mode : "longest" ->"longest" : "longest" ->padding : [number] ->[0] : [number] ->0 : 0 ->toArray : () => [number, ...(number | undefined)[]][] - -const c: (number | undefined)[][] = b; ->c : (number | undefined)[][] ->b : [number, ...(number | undefined)[]][] - -const d: number[][] = b; ->d : number[][] ->b : [number, ...(number | undefined)[]][] - -const e: Record> = { a: [1], b: [2, 3] }; ->e : Record> ->{ a: [1], b: [2, 3] } : { a: number[]; b: number[]; } ->a : number[] ->[1] : number[] ->1 : 1 ->b : number[] ->[2, 3] : number[] ->2 : 2 ->3 : 3 - -const f = Iterator.zipKeyed(e, { mode: "longest", padding: {} }).toArray(); ->f : { [x: string]: number | undefined; }[] ->Iterator.zipKeyed(e, { mode: "longest", padding: {} }).toArray() : { [x: string]: number | undefined; }[] ->Iterator.zipKeyed(e, { mode: "longest", padding: {} }).toArray : () => { [x: string]: number | undefined; }[] ->Iterator.zipKeyed(e, { mode: "longest", padding: {} }) : IteratorObject<{ [x: string]: number | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->e : Record> ->{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } ->mode : "longest" ->"longest" : "longest" ->padding : {} ->{} : {} ->toArray : () => { [x: string]: number | undefined; }[] - -const g: Record[] = f; ->g : Record[] ->f : { [x: string]: number | undefined; }[] - -const h: Record[] = f; ->h : Record[] ->f : { [x: string]: number | undefined; }[] - -declare const i: Record; ->i : Record - -const j = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: i }).toArray(); ->j : { a: number | undefined; b: number | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: i }).toArray() : { a: number | undefined; b: number | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: i }).toArray : () => { a: number | undefined; b: number | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: i }) : IteratorObject<{ a: number | undefined; b: number | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ a: [1], b: [2, 3] } : { a: number[]; b: number[]; } ->a : number[] ->[1] : number[] ->1 : 1 ->b : number[] ->[2, 3] : number[] ->2 : 2 ->3 : 3 ->{ mode: "longest", padding: i } : { mode: "longest"; padding: Record; } ->mode : "longest" ->"longest" : "longest" ->padding : Record ->i : Record ->toArray : () => { a: number | undefined; b: number | undefined; }[] - -const k: { a: number | undefined; b: number | undefined; }[] = j; ->k : { a: number | undefined; b: number | undefined; }[] ->a : number | undefined ->b : number | undefined ->j : { a: number | undefined; b: number | undefined; }[] - -const l: { a: number; b: number; }[] = j; ->l : { a: number; b: number; }[] ->a : number ->b : number ->j : { a: number | undefined; b: number | undefined; }[] - -const m = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); ->m : [number, string][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray() : [number, string][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray : () => [number, string][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }) : IteratorObject<[number, string], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->[[1], ["a"]] : [number[], string[]] ->[1] : number[] ->1 : 1 ->["a"] : string[] ->"a" : "a" ->{ mode: "longest", padding: [0, ""] } : { mode: "longest"; padding: [number, string]; } ->mode : "longest" ->"longest" : "longest" ->padding : [number, string] ->[0, ""] : [number, string] ->0 : 0 ->"" : "" ->toArray : () => [number, string][] - -const n: [number, string][] = m; ->n : [number, string][] ->m : [number, string][] - -const o = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); ->o : { a: number; b: string; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray() : { a: number; b: string; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray : () => { a: number; b: string; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }) : IteratorObject<{ a: number; b: string; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } ->a : number[] ->[1] : number[] ->1 : 1 ->b : string[] ->["a"] : string[] ->"a" : "a" ->{ mode: "longest", padding: { a: 0, b: "" } } : { mode: "longest"; padding: { a: number; b: string; }; } ->mode : "longest" ->"longest" : "longest" ->padding : { a: number; b: string; } ->{ a: 0, b: "" } : { a: number; b: string; } ->a : number ->0 : 0 ->b : string ->"" : "" ->toArray : () => { a: number; b: string; }[] - -const p: { a: number; b: string; }[] = o; ->p : { a: number; b: string; }[] ->a : number ->b : string ->o : { a: number; b: string; }[] - -const q = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); ->q : [number, string | undefined][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray() : [number, string | undefined][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray : () => [number, string | undefined][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }) : IteratorObject<[number, string | undefined], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->[[1], ["a"]] : [number[], string[]] ->[1] : number[] ->1 : 1 ->["a"] : string[] ->"a" : "a" ->{ mode: "longest", padding: [0] } : { mode: "longest"; padding: [number]; } ->mode : "longest" ->"longest" : "longest" ->padding : [number] ->[0] : [number] ->0 : 0 ->toArray : () => [number, string | undefined][] - -const r: [number | undefined, string | undefined][] = q; ->r : [number | undefined, string | undefined][] ->q : [number, string | undefined][] - -const s: [number, string][] = q; ->s : [number, string][] ->q : [number, string | undefined][] - -const t = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); ->t : { a: number; b: string | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray() : { a: number; b: string | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray : () => { a: number; b: string | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }) : IteratorObject<{ a: number; b: string | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } ->a : number[] ->[1] : number[] ->1 : 1 ->b : string[] ->["a"] : string[] ->"a" : "a" ->{ mode: "longest", padding: { a: 0 } } : { mode: "longest"; padding: { a: number; }; } ->mode : "longest" ->"longest" : "longest" ->padding : { a: number; } ->{ a: 0 } : { a: number; } ->a : number ->0 : 0 ->toArray : () => { a: number; b: string | undefined; }[] - -const u: { a: number | undefined; b: string | undefined; }[] = t; ->u : { a: number | undefined; b: string | undefined; }[] ->a : number | undefined ->b : string | undefined ->t : { a: number; b: string | undefined; }[] - -const v: { a: number; b: string; }[] = t; ->v : { a: number; b: string; }[] ->a : number ->b : string ->t : { a: number; b: string | undefined; }[] - -declare const w: readonly [number, string]; ->w : readonly [number, string] - -const x: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: w }).toArray(); ->x : [number, string][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: w }).toArray() : [number, string][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: w }).toArray : () => [number, string][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: w }) : IteratorObject<[number, string], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->[[1], ["a"]] : [number[], string[]] ->[1] : number[] ->1 : 1 ->["a"] : string[] ->"a" : "a" ->{ mode: "longest", padding: w } : { mode: "longest"; padding: readonly [number, string]; } ->mode : "longest" ->"longest" : "longest" ->padding : readonly [number, string] ->w : readonly [number, string] ->toArray : () => [number, string][] - -declare const y: [number, string?]; ->y : [number, (string | undefined)?] - -const z = Iterator.zip([[1], ["a"]], { mode: "longest", padding: y }).toArray(); ->z : [number, string | undefined][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: y }).toArray() : [number, string | undefined][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: y }).toArray : () => [number, string | undefined][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: y }) : IteratorObject<[number, string | undefined], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->[[1], ["a"]] : [number[], string[]] ->[1] : number[] ->1 : 1 ->["a"] : string[] ->"a" : "a" ->{ mode: "longest", padding: y } : { mode: "longest"; padding: [number, (string | undefined)?]; } ->mode : "longest" ->"longest" : "longest" ->padding : [number, (string | undefined)?] ->y : [number, (string | undefined)?] ->toArray : () => [number, string | undefined][] - -const a1: [number, string][] = z; ->a1 : [number, string][] ->z : [number, string | undefined][] - -declare const b1: [Iterable] | [Iterable, Iterable]; ->b1 : [Iterable] | [Iterable, Iterable] - -const c1 = Iterator.zip(b1, { mode: "longest", padding: [0] }).toArray(); ->c1 : ([number] | [number, number | undefined])[] ->Iterator.zip(b1, { mode: "longest", padding: [0] }).toArray() : ([number] | [number, number | undefined])[] ->Iterator.zip(b1, { mode: "longest", padding: [0] }).toArray : () => ([number] | [number, number | undefined])[] ->Iterator.zip(b1, { mode: "longest", padding: [0] }) : IteratorObject<[number] | [number, number | undefined], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->b1 : [Iterable] | [Iterable, Iterable] ->{ mode: "longest", padding: [0] } : { mode: "longest"; padding: [number]; } ->mode : "longest" ->"longest" : "longest" ->padding : [number] ->[0] : [number] ->0 : 0 ->toArray : () => ([number] | [number, number | undefined])[] - -const d1: number[][] = c1; ->d1 : number[][] ->c1 : ([number] | [number, number | undefined])[] - -declare const e1: { a: Iterable; } | { b: Iterable; }; ->e1 : { a: Iterable; } | { b: Iterable; } ->a : Iterable ->b : Iterable - -const f1 = Iterator.zipKeyed(e1, { mode: "longest", padding: { a: 0 } }).toArray(); ->f1 : ({ a: number; } | { b: string | undefined; })[] ->Iterator.zipKeyed(e1, { mode: "longest", padding: { a: 0 } }).toArray() : ({ a: number; } | { b: string | undefined; })[] ->Iterator.zipKeyed(e1, { mode: "longest", padding: { a: 0 } }).toArray : () => ({ a: number; } | { b: string | undefined; })[] ->Iterator.zipKeyed(e1, { mode: "longest", padding: { a: 0 } }) : IteratorObject<{ a: number; } | { b: string | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->e1 : { a: Iterable; } | { b: Iterable; } ->{ mode: "longest", padding: { a: 0 } } : { mode: "longest"; padding: { a: number; }; } ->mode : "longest" ->"longest" : "longest" ->padding : { a: number; } ->{ a: 0 } : { a: number; } ->a : number ->0 : 0 ->toArray : () => ({ a: number; } | { b: string | undefined; })[] - -const g1: ({ a: number; } | { b: string; })[] = f1; ->g1 : ({ a: number; } | { b: string; })[] ->a : number ->b : string ->f1 : ({ a: number; } | { b: string | undefined; })[] - -declare const h1: { a: number; } | { b: string; }; ->h1 : { a: number; } | { b: string; } ->a : number ->b : string - -const i1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: h1 }).toArray(); ->i1 : { a: number | undefined; b: string | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: h1 }).toArray() : { a: number | undefined; b: string | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: h1 }).toArray : () => { a: number | undefined; b: string | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: h1 }) : IteratorObject<{ a: number | undefined; b: string | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } ->a : number[] ->[1] : number[] ->1 : 1 ->b : string[] ->["a"] : string[] ->"a" : "a" ->{ mode: "longest", padding: h1 } : { mode: "longest"; padding: { a: number; } | { b: string; }; } ->mode : "longest" ->"longest" : "longest" ->padding : { a: number; } | { b: string; } ->h1 : { a: number; } | { b: string; } ->toArray : () => { a: number | undefined; b: string | undefined; }[] - -const j1: { a: number; b: string; }[] = i1; ->j1 : { a: number; b: string; }[] ->a : number ->b : string ->i1 : { a: number | undefined; b: string | undefined; }[] - -const k1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); ->k1 : { a: number | undefined; b: number; }[] ->Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray() : { a: number | undefined; b: number; }[] ->Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray : () => { a: number | undefined; b: number; }[] ->Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }) : IteratorObject<{ a: number | undefined; b: number; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ a: [1], b: [2] } : { a: number[]; b: number[]; } ->a : number[] ->[1] : number[] ->1 : 1 ->b : number[] ->[2] : number[] ->2 : 2 ->{ mode: "longest", padding: { a: undefined, b: 0 } } : { mode: "longest"; padding: { a: undefined; b: number; }; } ->mode : "longest" ->"longest" : "longest" ->padding : { a: undefined; b: number; } ->{ a: undefined, b: 0 } : { a: undefined; b: number; } ->a : undefined ->undefined : undefined ->b : number ->0 : 0 ->toArray : () => { a: number | undefined; b: number; }[] - -const l1: { a: number; b: number; }[] = k1; ->l1 : { a: number; b: number; }[] ->a : number ->b : number ->k1 : { a: number | undefined; b: number; }[] - -declare const m1: { [K in `a${string}`]: Iterable; }; ->m1 : { [x: `a${string}`]: Iterable; } - -const n1 = Iterator.zipKeyed(m1, { mode: "longest", padding: {} }).toArray(); ->n1 : { [x: `a${string}`]: number | undefined; }[] ->Iterator.zipKeyed(m1, { mode: "longest", padding: {} }).toArray() : { [x: `a${string}`]: number | undefined; }[] ->Iterator.zipKeyed(m1, { mode: "longest", padding: {} }).toArray : () => { [x: `a${string}`]: number | undefined; }[] ->Iterator.zipKeyed(m1, { mode: "longest", padding: {} }) : IteratorObject<{ [x: `a${string}`]: number | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->m1 : { [x: `a${string}`]: Iterable; } ->{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } ->mode : "longest" ->"longest" : "longest" ->padding : {} ->{} : {} ->toArray : () => { [x: `a${string}`]: number | undefined; }[] - -const o1: { [K in `a${string}`]: number; }[] = n1; ->o1 : { [x: `a${string}`]: number; }[] ->n1 : { [x: `a${string}`]: number | undefined; }[] - -declare const p1: unique symbol; ->p1 : unique symbol - -const q1: { [p1]: number; }[] = Iterator.zipKeyed({ [p1]: [1] }, { mode: "longest", padding: { [p1]: 0 } }).toArray(); ->q1 : { [p1]: number; }[] ->[p1] : number ->p1 : unique symbol ->Iterator.zipKeyed({ [p1]: [1] }, { mode: "longest", padding: { [p1]: 0 } }).toArray() : { [p1]: number; }[] ->Iterator.zipKeyed({ [p1]: [1] }, { mode: "longest", padding: { [p1]: 0 } }).toArray : () => { [p1]: number; }[] ->Iterator.zipKeyed({ [p1]: [1] }, { mode: "longest", padding: { [p1]: 0 } }) : IteratorObject<{ [p1]: number; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ [p1]: [1] } : { [p1]: number[]; } ->[p1] : number[] ->p1 : unique symbol ->[1] : number[] ->1 : 1 ->{ mode: "longest", padding: { [p1]: 0 } } : { mode: "longest"; padding: { [p1]: number; }; } ->mode : "longest" ->"longest" : "longest" ->padding : { [p1]: number; } ->{ [p1]: 0 } : { [p1]: number; } ->[p1] : number ->p1 : unique symbol ->0 : 0 ->toArray : () => { [p1]: number; }[] - -declare const r1: Record & { a: number; }; ->r1 : Record & { a: number; } ->a : number - -const s1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: r1 }).toArray(); ->s1 : { a: number; b: number | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: r1 }).toArray() : { a: number; b: number | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: r1 }).toArray : () => { a: number; b: number | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: r1 }) : IteratorObject<{ a: number; b: number | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ a: [1], b: [2] } : { a: number[]; b: number[]; } ->a : number[] ->[1] : number[] ->1 : 1 ->b : number[] ->[2] : number[] ->2 : 2 ->{ mode: "longest", padding: r1 } : { mode: "longest"; padding: Record & { a: number; }; } ->mode : "longest" ->"longest" : "longest" ->padding : Record & { a: number; } ->r1 : Record & { a: number; } ->toArray : () => { a: number; b: number | undefined; }[] - -const t1: { a: number; b: number | undefined; }[] = s1; ->t1 : { a: number; b: number | undefined; }[] ->a : number ->b : number | undefined ->s1 : { a: number; b: number | undefined; }[] - -const u1: { a: number; b: number; }[] = s1; ->u1 : { a: number; b: number; }[] ->a : number ->b : number ->s1 : { a: number; b: number | undefined; }[] - -declare const v1: [number] | [number, string]; ->v1 : [number] | [number, string] - -const w1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: v1 }).toArray(); ->w1 : [number, string | undefined][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: v1 }).toArray() : [number, string | undefined][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: v1 }).toArray : () => [number, string | undefined][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: v1 }) : IteratorObject<[number, string | undefined], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->[[1], ["a"]] : [number[], string[]] ->[1] : number[] ->1 : 1 ->["a"] : string[] ->"a" : "a" ->{ mode: "longest", padding: v1 } : { mode: "longest"; padding: [number] | [number, string]; } ->mode : "longest" ->"longest" : "longest" ->padding : [number] | [number, string] ->v1 : [number] | [number, string] ->toArray : () => [number, string | undefined][] - -const x1: [number, string | undefined][] = w1; ->x1 : [number, string | undefined][] ->w1 : [number, string | undefined][] - -const y1: [number, string][] = w1; ->y1 : [number, string][] ->w1 : [number, string | undefined][] - -const z1: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); ->z1 : [number | undefined, number][] ->Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray() : [number | undefined, number][] ->Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray : () => [number | undefined, number][] ->Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }) : IteratorObject<[number | undefined, number], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->[[1], [2]] : [number[], number[]] ->[1] : number[] ->1 : 1 ->[2] : number[] ->2 : 2 ->{ mode: "longest", padding: [undefined, 0] } : { mode: "longest"; padding: [undefined, number]; } ->mode : "longest" ->"longest" : "longest" ->padding : [undefined, number] ->[undefined, 0] : [undefined, number] ->undefined : undefined ->0 : 0 ->toArray : () => [number | undefined, number][] - -const a2: { a: number | undefined; b: number; }[] = k1; ->a2 : { a: number | undefined; b: number; }[] ->a : number | undefined ->b : number ->k1 : { a: number | undefined; b: number; }[] - diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=true).errors.txt b/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=true).errors.txt deleted file mode 100644 index 4ba9821668036..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=true).errors.txt +++ /dev/null @@ -1,215 +0,0 @@ -iteratorZipPadding.ts(4,7): error TS2322: Type '[number, ...(number | undefined)[]][]' is not assignable to type 'number[][]'. - Type '[number, ...(number | undefined)[]]' is not assignable to type 'number[]'. - Type 'number | undefined' is not assignable to type 'number'. - Type 'undefined' is not assignable to type 'number'. -iteratorZipPadding.ts(9,7): error TS2322: Type 'IteratorZipResult<{ [x: string]: Iterable; } & {}, undefined, {}>[]' is not assignable to type 'Record[]'. - Type 'IteratorZipResult<{ [x: string]: Iterable; } & {}, undefined, {}>' is not assignable to type 'Record'. - 'string' index signatures are incompatible. - Type 'number | undefined' is not assignable to type 'number'. - Type 'undefined' is not assignable to type 'number'. -iteratorZipPadding.ts(14,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record>[]' is not assignable to type '{ a: number; b: number; }[]'. - Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record>' is not assignable to type '{ a: number; b: number; }'. - Types of property 'a' are incompatible. - Type 'number | undefined' is not assignable to type 'number'. - Type 'undefined' is not assignable to type 'number'. -iteratorZipPadding.ts(23,7): error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. - Type '[number, string | undefined]' is not assignable to type '[number, string]'. - Type at position 1 in source is not compatible with type at position 1 in target. - Type 'string | undefined' is not assignable to type 'string'. - Type 'undefined' is not assignable to type 'string'. -iteratorZipPadding.ts(26,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; }>[]' is not assignable to type '{ a: number; b: string; }[]'. - Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; b: string; }'. - Types of property 'b' are incompatible. - Type 'string | undefined' is not assignable to type 'string'. - Type 'undefined' is not assignable to type 'string'. -iteratorZipPadding.ts(32,7): error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. - Type '[number, string | undefined]' is not assignable to type '[number, string]'. - Type at position 1 in source is not compatible with type at position 1 in target. - Type 'string | undefined' is not assignable to type 'string'. - Type 'undefined' is not assignable to type 'string'. -iteratorZipPadding.ts(36,7): error TS2322: Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>[]' is not assignable to type 'number[][]'. - Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>' is not assignable to type 'number[]'. - Type '[number, number | undefined]' is not assignable to type 'number[]'. - Type 'number | undefined' is not assignable to type 'number'. - Type 'undefined' is not assignable to type 'number'. -iteratorZipPadding.ts(39,7): error TS2322: Type '(IteratorZipResult<{ a: Iterable; } & {}, undefined, { a: number; }> | IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>)[]' is not assignable to type '({ a: number; } | { b: string; })[]'. - Type 'IteratorZipResult<{ a: Iterable; } & {}, undefined, { a: number; }> | IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; } | { b: string; }'. - Type 'IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; } | { b: string; }'. - Type 'IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ b: string; }'. - Types of property 'b' are incompatible. - Type 'string | undefined' is not assignable to type 'string'. - Type 'undefined' is not assignable to type 'string'. -iteratorZipPadding.ts(43,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; } | { b: string; }>[]' is not assignable to type '{ a: number; b: string; }[]'. - Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; } | { b: string; }>' is not assignable to type '{ a: number; b: string; }'. - Types of property 'a' are incompatible. - Type 'number | undefined' is not assignable to type 'number'. - Type 'undefined' is not assignable to type 'number'. -iteratorZipPadding.ts(46,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, { a: undefined; b: number; }>[]' is not assignable to type '{ a: number; b: number; }[]'. - Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, { a: undefined; b: number; }>' is not assignable to type '{ a: number; b: number; }'. - Types of property 'a' are incompatible. - Type 'number | undefined' is not assignable to type 'number'. - Type 'undefined' is not assignable to type 'number'. -iteratorZipPadding.ts(50,7): error TS2322: Type 'IteratorZipResult<{ [x: `a${string}`]: Iterable; } & {}, undefined, {}>[]' is not assignable to type '{ [x: `a${string}`]: number; }[]'. - Type 'IteratorZipResult<{ [x: `a${string}`]: Iterable; } & {}, undefined, {}>' is not assignable to type '{ [x: `a${string}`]: number; }'. - '`a${string}`' index signatures are incompatible. - Type 'number | undefined' is not assignable to type 'number'. - Type 'undefined' is not assignable to type 'number'. -iteratorZipPadding.ts(58,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record & { a: number; }>[]' is not assignable to type '{ a: number; b: number; }[]'. - Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record & { a: number; }>' is not assignable to type '{ a: number; b: number; }'. - Types of property 'b' are incompatible. - Type 'number | undefined' is not assignable to type 'number'. - Type 'undefined' is not assignable to type 'number'. -iteratorZipPadding.ts(63,7): error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. - Type '[number, string | undefined]' is not assignable to type '[number, string]'. - Type at position 1 in source is not compatible with type at position 1 in target. - Type 'string | undefined' is not assignable to type 'string'. - Type 'undefined' is not assignable to type 'string'. - - -==== iteratorZipPadding.ts (13 errors) ==== - const a: [Iterable, ...Iterable[]] = [[1, 2], [3]]; - const b = Iterator.zip(a, { mode: "longest", padding: [0] }).toArray(); - const c: (number | undefined)[][] = b; - const d: number[][] = b; - ~ -!!! error TS2322: Type '[number, ...(number | undefined)[]][]' is not assignable to type 'number[][]'. -!!! error TS2322: Type '[number, ...(number | undefined)[]]' is not assignable to type 'number[]'. -!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. -!!! error TS2322: Type 'undefined' is not assignable to type 'number'. - - const e: Record> = { a: [1], b: [2, 3] }; - const f = Iterator.zipKeyed(e, { mode: "longest", padding: {} }).toArray(); - const g: Record[] = f; - const h: Record[] = f; - ~ -!!! error TS2322: Type 'IteratorZipResult<{ [x: string]: Iterable; } & {}, undefined, {}>[]' is not assignable to type 'Record[]'. -!!! error TS2322: Type 'IteratorZipResult<{ [x: string]: Iterable; } & {}, undefined, {}>' is not assignable to type 'Record'. -!!! error TS2322: 'string' index signatures are incompatible. -!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. -!!! error TS2322: Type 'undefined' is not assignable to type 'number'. - - declare const i: Record; - const j = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: i }).toArray(); - const k: { a: number | undefined; b: number | undefined; }[] = j; - const l: { a: number; b: number; }[] = j; - ~ -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record>[]' is not assignable to type '{ a: number; b: number; }[]'. -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record>' is not assignable to type '{ a: number; b: number; }'. -!!! error TS2322: Types of property 'a' are incompatible. -!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. -!!! error TS2322: Type 'undefined' is not assignable to type 'number'. - - const m = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); - const n: [number, string][] = m; - const o = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); - const p: { a: number; b: string; }[] = o; - - const q = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); - const r: [number | undefined, string | undefined][] = q; - const s: [number, string][] = q; - ~ -!!! error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. -!!! error TS2322: Type '[number, string | undefined]' is not assignable to type '[number, string]'. -!!! error TS2322: Type at position 1 in source is not compatible with type at position 1 in target. -!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. -!!! error TS2322: Type 'undefined' is not assignable to type 'string'. - const t = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); - const u: { a: number | undefined; b: string | undefined; }[] = t; - const v: { a: number; b: string; }[] = t; - ~ -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; }>[]' is not assignable to type '{ a: number; b: string; }[]'. -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; b: string; }'. -!!! error TS2322: Types of property 'b' are incompatible. -!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. -!!! error TS2322: Type 'undefined' is not assignable to type 'string'. - - declare const w: readonly [number, string]; - const x: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: w }).toArray(); - declare const y: [number, string?]; - const z = Iterator.zip([[1], ["a"]], { mode: "longest", padding: y }).toArray(); - const a1: [number, string][] = z; - ~~ -!!! error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. -!!! error TS2322: Type '[number, string | undefined]' is not assignable to type '[number, string]'. -!!! error TS2322: Type at position 1 in source is not compatible with type at position 1 in target. -!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. -!!! error TS2322: Type 'undefined' is not assignable to type 'string'. - - declare const b1: [Iterable] | [Iterable, Iterable]; - const c1 = Iterator.zip(b1, { mode: "longest", padding: [0] }).toArray(); - const d1: number[][] = c1; - ~~ -!!! error TS2322: Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>[]' is not assignable to type 'number[][]'. -!!! error TS2322: Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>' is not assignable to type 'number[]'. -!!! error TS2322: Type '[number, number | undefined]' is not assignable to type 'number[]'. -!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. -!!! error TS2322: Type 'undefined' is not assignable to type 'number'. - declare const e1: { a: Iterable; } | { b: Iterable; }; - const f1 = Iterator.zipKeyed(e1, { mode: "longest", padding: { a: 0 } }).toArray(); - const g1: ({ a: number; } | { b: string; })[] = f1; - ~~ -!!! error TS2322: Type '(IteratorZipResult<{ a: Iterable; } & {}, undefined, { a: number; }> | IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>)[]' is not assignable to type '({ a: number; } | { b: string; })[]'. -!!! error TS2322: Type 'IteratorZipResult<{ a: Iterable; } & {}, undefined, { a: number; }> | IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; } | { b: string; }'. -!!! error TS2322: Type 'IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; } | { b: string; }'. -!!! error TS2322: Type 'IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ b: string; }'. -!!! error TS2322: Types of property 'b' are incompatible. -!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. -!!! error TS2322: Type 'undefined' is not assignable to type 'string'. - - declare const h1: { a: number; } | { b: string; }; - const i1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: h1 }).toArray(); - const j1: { a: number; b: string; }[] = i1; - ~~ -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; } | { b: string; }>[]' is not assignable to type '{ a: number; b: string; }[]'. -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; } | { b: string; }>' is not assignable to type '{ a: number; b: string; }'. -!!! error TS2322: Types of property 'a' are incompatible. -!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. -!!! error TS2322: Type 'undefined' is not assignable to type 'number'. - - const k1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); - const l1: { a: number; b: number; }[] = k1; - ~~ -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, { a: undefined; b: number; }>[]' is not assignable to type '{ a: number; b: number; }[]'. -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, { a: undefined; b: number; }>' is not assignable to type '{ a: number; b: number; }'. -!!! error TS2322: Types of property 'a' are incompatible. -!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. -!!! error TS2322: Type 'undefined' is not assignable to type 'number'. - - declare const m1: { [K in `a${string}`]: Iterable; }; - const n1 = Iterator.zipKeyed(m1, { mode: "longest", padding: {} }).toArray(); - const o1: { [K in `a${string}`]: number; }[] = n1; - ~~ -!!! error TS2322: Type 'IteratorZipResult<{ [x: `a${string}`]: Iterable; } & {}, undefined, {}>[]' is not assignable to type '{ [x: `a${string}`]: number; }[]'. -!!! error TS2322: Type 'IteratorZipResult<{ [x: `a${string}`]: Iterable; } & {}, undefined, {}>' is not assignable to type '{ [x: `a${string}`]: number; }'. -!!! error TS2322: '`a${string}`' index signatures are incompatible. -!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. -!!! error TS2322: Type 'undefined' is not assignable to type 'number'. - - declare const p1: unique symbol; - const q1: { [p1]: number; }[] = Iterator.zipKeyed({ [p1]: [1] }, { mode: "longest", padding: { [p1]: 0 } }).toArray(); - - declare const r1: Record & { a: number; }; - const s1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: r1 }).toArray(); - const t1: { a: number; b: number | undefined; }[] = s1; - const u1: { a: number; b: number; }[] = s1; - ~~ -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record & { a: number; }>[]' is not assignable to type '{ a: number; b: number; }[]'. -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record & { a: number; }>' is not assignable to type '{ a: number; b: number; }'. -!!! error TS2322: Types of property 'b' are incompatible. -!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. -!!! error TS2322: Type 'undefined' is not assignable to type 'number'. - - declare const v1: [number] | [number, string]; - const w1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: v1 }).toArray(); - const x1: [number, string | undefined][] = w1; - const y1: [number, string][] = w1; - ~~ -!!! error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. -!!! error TS2322: Type '[number, string | undefined]' is not assignable to type '[number, string]'. -!!! error TS2322: Type at position 1 in source is not compatible with type at position 1 in target. -!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. -!!! error TS2322: Type 'undefined' is not assignable to type 'string'. - - const z1: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); - const a2: { a: number | undefined; b: number; }[] = k1; - \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=true).js b/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=true).js deleted file mode 100644 index 408ebf1bc1fac..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=true).js +++ /dev/null @@ -1,248 +0,0 @@ -//// [tests/cases/compiler/iteratorZipPadding.ts] //// - -//// [iteratorZipPadding.ts] -const a: [Iterable, ...Iterable[]] = [[1, 2], [3]]; -const b = Iterator.zip(a, { mode: "longest", padding: [0] }).toArray(); -const c: (number | undefined)[][] = b; -const d: number[][] = b; - -const e: Record> = { a: [1], b: [2, 3] }; -const f = Iterator.zipKeyed(e, { mode: "longest", padding: {} }).toArray(); -const g: Record[] = f; -const h: Record[] = f; - -declare const i: Record; -const j = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: i }).toArray(); -const k: { a: number | undefined; b: number | undefined; }[] = j; -const l: { a: number; b: number; }[] = j; - -const m = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); -const n: [number, string][] = m; -const o = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); -const p: { a: number; b: string; }[] = o; - -const q = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); -const r: [number | undefined, string | undefined][] = q; -const s: [number, string][] = q; -const t = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); -const u: { a: number | undefined; b: string | undefined; }[] = t; -const v: { a: number; b: string; }[] = t; - -declare const w: readonly [number, string]; -const x: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: w }).toArray(); -declare const y: [number, string?]; -const z = Iterator.zip([[1], ["a"]], { mode: "longest", padding: y }).toArray(); -const a1: [number, string][] = z; - -declare const b1: [Iterable] | [Iterable, Iterable]; -const c1 = Iterator.zip(b1, { mode: "longest", padding: [0] }).toArray(); -const d1: number[][] = c1; -declare const e1: { a: Iterable; } | { b: Iterable; }; -const f1 = Iterator.zipKeyed(e1, { mode: "longest", padding: { a: 0 } }).toArray(); -const g1: ({ a: number; } | { b: string; })[] = f1; - -declare const h1: { a: number; } | { b: string; }; -const i1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: h1 }).toArray(); -const j1: { a: number; b: string; }[] = i1; - -const k1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); -const l1: { a: number; b: number; }[] = k1; - -declare const m1: { [K in `a${string}`]: Iterable; }; -const n1 = Iterator.zipKeyed(m1, { mode: "longest", padding: {} }).toArray(); -const o1: { [K in `a${string}`]: number; }[] = n1; - -declare const p1: unique symbol; -const q1: { [p1]: number; }[] = Iterator.zipKeyed({ [p1]: [1] }, { mode: "longest", padding: { [p1]: 0 } }).toArray(); - -declare const r1: Record & { a: number; }; -const s1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: r1 }).toArray(); -const t1: { a: number; b: number | undefined; }[] = s1; -const u1: { a: number; b: number; }[] = s1; - -declare const v1: [number] | [number, string]; -const w1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: v1 }).toArray(); -const x1: [number, string | undefined][] = w1; -const y1: [number, string][] = w1; - -const z1: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); -const a2: { a: number | undefined; b: number; }[] = k1; - - -//// [iteratorZipPadding.js] -"use strict"; -const a = [[1, 2], [3]]; -const b = Iterator.zip(a, { mode: "longest", padding: [0] }).toArray(); -const c = b; -const d = b; -const e = { a: [1], b: [2, 3] }; -const f = Iterator.zipKeyed(e, { mode: "longest", padding: {} }).toArray(); -const g = f; -const h = f; -const j = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: i }).toArray(); -const k = j; -const l = j; -const m = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); -const n = m; -const o = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); -const p = o; -const q = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); -const r = q; -const s = q; -const t = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); -const u = t; -const v = t; -const x = Iterator.zip([[1], ["a"]], { mode: "longest", padding: w }).toArray(); -const z = Iterator.zip([[1], ["a"]], { mode: "longest", padding: y }).toArray(); -const a1 = z; -const c1 = Iterator.zip(b1, { mode: "longest", padding: [0] }).toArray(); -const d1 = c1; -const f1 = Iterator.zipKeyed(e1, { mode: "longest", padding: { a: 0 } }).toArray(); -const g1 = f1; -const i1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: h1 }).toArray(); -const j1 = i1; -const k1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); -const l1 = k1; -const n1 = Iterator.zipKeyed(m1, { mode: "longest", padding: {} }).toArray(); -const o1 = n1; -const q1 = Iterator.zipKeyed({ [p1]: [1] }, { mode: "longest", padding: { [p1]: 0 } }).toArray(); -const s1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: r1 }).toArray(); -const t1 = s1; -const u1 = s1; -const w1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: v1 }).toArray(); -const x1 = w1; -const y1 = w1; -const z1 = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); -const a2 = k1; - - -//// [iteratorZipPadding.d.ts] -declare const a: [Iterable, ...Iterable[]]; -declare const b: [number, ...(number | undefined)[]][]; -declare const c: (number | undefined)[][]; -declare const d: number[][]; -declare const e: Record>; -declare const f: { - [x: string]: number | undefined; -}[]; -declare const g: Record[]; -declare const h: Record[]; -declare const i: Record; -declare const j: { - a: number | undefined; - b: number | undefined; -}[]; -declare const k: { - a: number | undefined; - b: number | undefined; -}[]; -declare const l: { - a: number; - b: number; -}[]; -declare const m: [number, string][]; -declare const n: [number, string][]; -declare const o: { - a: number; - b: string; -}[]; -declare const p: { - a: number; - b: string; -}[]; -declare const q: [number, string | undefined][]; -declare const r: [number | undefined, string | undefined][]; -declare const s: [number, string][]; -declare const t: { - a: number; - b: string | undefined; -}[]; -declare const u: { - a: number | undefined; - b: string | undefined; -}[]; -declare const v: { - a: number; - b: string; -}[]; -declare const w: readonly [number, string]; -declare const x: [number, string][]; -declare const y: [number, string?]; -declare const z: [number, string | undefined][]; -declare const a1: [number, string][]; -declare const b1: [Iterable] | [Iterable, Iterable]; -declare const c1: ([number] | [number, number | undefined])[]; -declare const d1: number[][]; -declare const e1: { - a: Iterable; -} | { - b: Iterable; -}; -declare const f1: ({ - a: number; -} | { - b: string | undefined; -})[]; -declare const g1: ({ - a: number; -} | { - b: string; -})[]; -declare const h1: { - a: number; -} | { - b: string; -}; -declare const i1: { - a: number | undefined; - b: string | undefined; -}[]; -declare const j1: { - a: number; - b: string; -}[]; -declare const k1: { - a: number | undefined; - b: number; -}[]; -declare const l1: { - a: number; - b: number; -}[]; -declare const m1: { - [K in `a${string}`]: Iterable; -}; -declare const n1: { - [x: `a${string}`]: number | undefined; -}[]; -declare const o1: { - [K in `a${string}`]: number; -}[]; -declare const p1: unique symbol; -declare const q1: { - [p1]: number; -}[]; -declare const r1: Record & { - a: number; -}; -declare const s1: { - a: number; - b: number | undefined; -}[]; -declare const t1: { - a: number; - b: number | undefined; -}[]; -declare const u1: { - a: number; - b: number; -}[]; -declare const v1: [number] | [number, string]; -declare const w1: [number, string | undefined][]; -declare const x1: [number, string | undefined][]; -declare const y1: [number, string][]; -declare const z1: [number | undefined, number][]; -declare const a2: { - a: number | undefined; - b: number; -}[]; diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=true).symbols b/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=true).symbols deleted file mode 100644 index 7284c5da3fbf8..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=true).symbols +++ /dev/null @@ -1,393 +0,0 @@ -//// [tests/cases/compiler/iteratorZipPadding.ts] //// - -=== iteratorZipPadding.ts === -const a: [Iterable, ...Iterable[]] = [[1, 2], [3]]; ->a : Symbol(a, Decl(iteratorZipPadding.ts, 0, 5)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) - -const b = Iterator.zip(a, { mode: "longest", padding: [0] }).toArray(); ->b : Symbol(b, Decl(iteratorZipPadding.ts, 1, 5)) ->Iterator.zip(a, { mode: "longest", padding: [0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 0, 5)) ->mode : Symbol(mode, Decl(iteratorZipPadding.ts, 1, 27)) ->padding : Symbol(padding, Decl(iteratorZipPadding.ts, 1, 44)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const c: (number | undefined)[][] = b; ->c : Symbol(c, Decl(iteratorZipPadding.ts, 2, 5)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 1, 5)) - -const d: number[][] = b; ->d : Symbol(d, Decl(iteratorZipPadding.ts, 3, 5)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 1, 5)) - -const e: Record> = { a: [1], b: [2, 3] }; ->e : Symbol(e, Decl(iteratorZipPadding.ts, 5, 5)) ->Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 5, 45)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 5, 53)) - -const f = Iterator.zipKeyed(e, { mode: "longest", padding: {} }).toArray(); ->f : Symbol(f, Decl(iteratorZipPadding.ts, 6, 5)) ->Iterator.zipKeyed(e, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->e : Symbol(e, Decl(iteratorZipPadding.ts, 5, 5)) ->mode : Symbol(mode, Decl(iteratorZipPadding.ts, 6, 32)) ->padding : Symbol(padding, Decl(iteratorZipPadding.ts, 6, 49)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const g: Record[] = f; ->g : Symbol(g, Decl(iteratorZipPadding.ts, 7, 5)) ->Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) ->f : Symbol(f, Decl(iteratorZipPadding.ts, 6, 5)) - -const h: Record[] = f; ->h : Symbol(h, Decl(iteratorZipPadding.ts, 8, 5)) ->Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) ->f : Symbol(f, Decl(iteratorZipPadding.ts, 6, 5)) - -declare const i: Record; ->i : Symbol(i, Decl(iteratorZipPadding.ts, 10, 13)) ->Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) - -const j = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: i }).toArray(); ->j : Symbol(j, Decl(iteratorZipPadding.ts, 11, 5)) ->Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: i }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 11, 29)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 11, 37)) ->mode : Symbol(mode, Decl(iteratorZipPadding.ts, 11, 52)) ->padding : Symbol(padding, Decl(iteratorZipPadding.ts, 11, 69)) ->i : Symbol(i, Decl(iteratorZipPadding.ts, 10, 13)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const k: { a: number | undefined; b: number | undefined; }[] = j; ->k : Symbol(k, Decl(iteratorZipPadding.ts, 12, 5)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 12, 10)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 12, 33)) ->j : Symbol(j, Decl(iteratorZipPadding.ts, 11, 5)) - -const l: { a: number; b: number; }[] = j; ->l : Symbol(l, Decl(iteratorZipPadding.ts, 13, 5)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 13, 10)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 13, 21)) ->j : Symbol(j, Decl(iteratorZipPadding.ts, 11, 5)) - -const m = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); ->m : Symbol(m, Decl(iteratorZipPadding.ts, 15, 5)) ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZipPadding.ts, 15, 38)) ->padding : Symbol(padding, Decl(iteratorZipPadding.ts, 15, 55)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const n: [number, string][] = m; ->n : Symbol(n, Decl(iteratorZipPadding.ts, 16, 5)) ->m : Symbol(m, Decl(iteratorZipPadding.ts, 15, 5)) - -const o = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); ->o : Symbol(o, Decl(iteratorZipPadding.ts, 17, 5)) ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 17, 29)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 17, 37)) ->mode : Symbol(mode, Decl(iteratorZipPadding.ts, 17, 51)) ->padding : Symbol(padding, Decl(iteratorZipPadding.ts, 17, 68)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 17, 79)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 17, 85)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const p: { a: number; b: string; }[] = o; ->p : Symbol(p, Decl(iteratorZipPadding.ts, 18, 5)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 18, 10)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 18, 21)) ->o : Symbol(o, Decl(iteratorZipPadding.ts, 17, 5)) - -const q = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); ->q : Symbol(q, Decl(iteratorZipPadding.ts, 20, 5)) ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZipPadding.ts, 20, 38)) ->padding : Symbol(padding, Decl(iteratorZipPadding.ts, 20, 55)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const r: [number | undefined, string | undefined][] = q; ->r : Symbol(r, Decl(iteratorZipPadding.ts, 21, 5)) ->q : Symbol(q, Decl(iteratorZipPadding.ts, 20, 5)) - -const s: [number, string][] = q; ->s : Symbol(s, Decl(iteratorZipPadding.ts, 22, 5)) ->q : Symbol(q, Decl(iteratorZipPadding.ts, 20, 5)) - -const t = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); ->t : Symbol(t, Decl(iteratorZipPadding.ts, 23, 5)) ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 23, 29)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 23, 37)) ->mode : Symbol(mode, Decl(iteratorZipPadding.ts, 23, 51)) ->padding : Symbol(padding, Decl(iteratorZipPadding.ts, 23, 68)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 23, 79)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const u: { a: number | undefined; b: string | undefined; }[] = t; ->u : Symbol(u, Decl(iteratorZipPadding.ts, 24, 5)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 24, 10)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 24, 33)) ->t : Symbol(t, Decl(iteratorZipPadding.ts, 23, 5)) - -const v: { a: number; b: string; }[] = t; ->v : Symbol(v, Decl(iteratorZipPadding.ts, 25, 5)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 25, 10)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 25, 21)) ->t : Symbol(t, Decl(iteratorZipPadding.ts, 23, 5)) - -declare const w: readonly [number, string]; ->w : Symbol(w, Decl(iteratorZipPadding.ts, 27, 13)) - -const x: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: w }).toArray(); ->x : Symbol(x, Decl(iteratorZipPadding.ts, 28, 5)) ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: w }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZipPadding.ts, 28, 58)) ->padding : Symbol(padding, Decl(iteratorZipPadding.ts, 28, 75)) ->w : Symbol(w, Decl(iteratorZipPadding.ts, 27, 13)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -declare const y: [number, string?]; ->y : Symbol(y, Decl(iteratorZipPadding.ts, 29, 13)) - -const z = Iterator.zip([[1], ["a"]], { mode: "longest", padding: y }).toArray(); ->z : Symbol(z, Decl(iteratorZipPadding.ts, 30, 5)) ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: y }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZipPadding.ts, 30, 38)) ->padding : Symbol(padding, Decl(iteratorZipPadding.ts, 30, 55)) ->y : Symbol(y, Decl(iteratorZipPadding.ts, 29, 13)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const a1: [number, string][] = z; ->a1 : Symbol(a1, Decl(iteratorZipPadding.ts, 31, 5)) ->z : Symbol(z, Decl(iteratorZipPadding.ts, 30, 5)) - -declare const b1: [Iterable] | [Iterable, Iterable]; ->b1 : Symbol(b1, Decl(iteratorZipPadding.ts, 33, 13)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) - -const c1 = Iterator.zip(b1, { mode: "longest", padding: [0] }).toArray(); ->c1 : Symbol(c1, Decl(iteratorZipPadding.ts, 34, 5)) ->Iterator.zip(b1, { mode: "longest", padding: [0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->b1 : Symbol(b1, Decl(iteratorZipPadding.ts, 33, 13)) ->mode : Symbol(mode, Decl(iteratorZipPadding.ts, 34, 29)) ->padding : Symbol(padding, Decl(iteratorZipPadding.ts, 34, 46)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const d1: number[][] = c1; ->d1 : Symbol(d1, Decl(iteratorZipPadding.ts, 35, 5)) ->c1 : Symbol(c1, Decl(iteratorZipPadding.ts, 34, 5)) - -declare const e1: { a: Iterable; } | { b: Iterable; }; ->e1 : Symbol(e1, Decl(iteratorZipPadding.ts, 36, 13)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 36, 19)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 36, 46)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) - -const f1 = Iterator.zipKeyed(e1, { mode: "longest", padding: { a: 0 } }).toArray(); ->f1 : Symbol(f1, Decl(iteratorZipPadding.ts, 37, 5)) ->Iterator.zipKeyed(e1, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->e1 : Symbol(e1, Decl(iteratorZipPadding.ts, 36, 13)) ->mode : Symbol(mode, Decl(iteratorZipPadding.ts, 37, 34)) ->padding : Symbol(padding, Decl(iteratorZipPadding.ts, 37, 51)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 37, 62)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const g1: ({ a: number; } | { b: string; })[] = f1; ->g1 : Symbol(g1, Decl(iteratorZipPadding.ts, 38, 5)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 38, 12)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 38, 29)) ->f1 : Symbol(f1, Decl(iteratorZipPadding.ts, 37, 5)) - -declare const h1: { a: number; } | { b: string; }; ->h1 : Symbol(h1, Decl(iteratorZipPadding.ts, 40, 13)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 40, 19)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 40, 36)) - -const i1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: h1 }).toArray(); ->i1 : Symbol(i1, Decl(iteratorZipPadding.ts, 41, 5)) ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: h1 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 41, 30)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 41, 38)) ->mode : Symbol(mode, Decl(iteratorZipPadding.ts, 41, 52)) ->padding : Symbol(padding, Decl(iteratorZipPadding.ts, 41, 69)) ->h1 : Symbol(h1, Decl(iteratorZipPadding.ts, 40, 13)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const j1: { a: number; b: string; }[] = i1; ->j1 : Symbol(j1, Decl(iteratorZipPadding.ts, 42, 5)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 42, 11)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 42, 22)) ->i1 : Symbol(i1, Decl(iteratorZipPadding.ts, 41, 5)) - -const k1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); ->k1 : Symbol(k1, Decl(iteratorZipPadding.ts, 44, 5)) ->Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 44, 30)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 44, 38)) ->mode : Symbol(mode, Decl(iteratorZipPadding.ts, 44, 50)) ->padding : Symbol(padding, Decl(iteratorZipPadding.ts, 44, 67)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 44, 78)) ->undefined : Symbol(undefined) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 44, 92)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const l1: { a: number; b: number; }[] = k1; ->l1 : Symbol(l1, Decl(iteratorZipPadding.ts, 45, 5)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 45, 11)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 45, 22)) ->k1 : Symbol(k1, Decl(iteratorZipPadding.ts, 44, 5)) - -declare const m1: { [K in `a${string}`]: Iterable; }; ->m1 : Symbol(m1, Decl(iteratorZipPadding.ts, 47, 13)) ->K : Symbol(K, Decl(iteratorZipPadding.ts, 47, 21)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) - -const n1 = Iterator.zipKeyed(m1, { mode: "longest", padding: {} }).toArray(); ->n1 : Symbol(n1, Decl(iteratorZipPadding.ts, 48, 5)) ->Iterator.zipKeyed(m1, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->m1 : Symbol(m1, Decl(iteratorZipPadding.ts, 47, 13)) ->mode : Symbol(mode, Decl(iteratorZipPadding.ts, 48, 34)) ->padding : Symbol(padding, Decl(iteratorZipPadding.ts, 48, 51)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const o1: { [K in `a${string}`]: number; }[] = n1; ->o1 : Symbol(o1, Decl(iteratorZipPadding.ts, 49, 5)) ->K : Symbol(K, Decl(iteratorZipPadding.ts, 49, 13)) ->n1 : Symbol(n1, Decl(iteratorZipPadding.ts, 48, 5)) - -declare const p1: unique symbol; ->p1 : Symbol(p1, Decl(iteratorZipPadding.ts, 51, 13)) - -const q1: { [p1]: number; }[] = Iterator.zipKeyed({ [p1]: [1] }, { mode: "longest", padding: { [p1]: 0 } }).toArray(); ->q1 : Symbol(q1, Decl(iteratorZipPadding.ts, 52, 5)) ->[p1] : Symbol([p1], Decl(iteratorZipPadding.ts, 52, 11)) ->p1 : Symbol(p1, Decl(iteratorZipPadding.ts, 51, 13)) ->Iterator.zipKeyed({ [p1]: [1] }, { mode: "longest", padding: { [p1]: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->[p1] : Symbol([p1], Decl(iteratorZipPadding.ts, 52, 51)) ->p1 : Symbol(p1, Decl(iteratorZipPadding.ts, 51, 13)) ->mode : Symbol(mode, Decl(iteratorZipPadding.ts, 52, 66)) ->padding : Symbol(padding, Decl(iteratorZipPadding.ts, 52, 83)) ->[p1] : Symbol([p1], Decl(iteratorZipPadding.ts, 52, 94)) ->p1 : Symbol(p1, Decl(iteratorZipPadding.ts, 51, 13)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -declare const r1: Record & { a: number; }; ->r1 : Symbol(r1, Decl(iteratorZipPadding.ts, 54, 13)) ->Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 54, 44)) - -const s1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: r1 }).toArray(); ->s1 : Symbol(s1, Decl(iteratorZipPadding.ts, 55, 5)) ->Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: r1 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 55, 30)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 55, 38)) ->mode : Symbol(mode, Decl(iteratorZipPadding.ts, 55, 50)) ->padding : Symbol(padding, Decl(iteratorZipPadding.ts, 55, 67)) ->r1 : Symbol(r1, Decl(iteratorZipPadding.ts, 54, 13)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const t1: { a: number; b: number | undefined; }[] = s1; ->t1 : Symbol(t1, Decl(iteratorZipPadding.ts, 56, 5)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 56, 11)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 56, 22)) ->s1 : Symbol(s1, Decl(iteratorZipPadding.ts, 55, 5)) - -const u1: { a: number; b: number; }[] = s1; ->u1 : Symbol(u1, Decl(iteratorZipPadding.ts, 57, 5)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 57, 11)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 57, 22)) ->s1 : Symbol(s1, Decl(iteratorZipPadding.ts, 55, 5)) - -declare const v1: [number] | [number, string]; ->v1 : Symbol(v1, Decl(iteratorZipPadding.ts, 59, 13)) - -const w1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: v1 }).toArray(); ->w1 : Symbol(w1, Decl(iteratorZipPadding.ts, 60, 5)) ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: v1 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZipPadding.ts, 60, 39)) ->padding : Symbol(padding, Decl(iteratorZipPadding.ts, 60, 56)) ->v1 : Symbol(v1, Decl(iteratorZipPadding.ts, 59, 13)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const x1: [number, string | undefined][] = w1; ->x1 : Symbol(x1, Decl(iteratorZipPadding.ts, 61, 5)) ->w1 : Symbol(w1, Decl(iteratorZipPadding.ts, 60, 5)) - -const y1: [number, string][] = w1; ->y1 : Symbol(y1, Decl(iteratorZipPadding.ts, 62, 5)) ->w1 : Symbol(w1, Decl(iteratorZipPadding.ts, 60, 5)) - -const z1: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); ->z1 : Symbol(z1, Decl(iteratorZipPadding.ts, 64, 5)) ->Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZipPadding.ts, 64, 69)) ->padding : Symbol(padding, Decl(iteratorZipPadding.ts, 64, 86)) ->undefined : Symbol(undefined) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const a2: { a: number | undefined; b: number; }[] = k1; ->a2 : Symbol(a2, Decl(iteratorZipPadding.ts, 65, 5)) ->a : Symbol(a, Decl(iteratorZipPadding.ts, 65, 11)) ->b : Symbol(b, Decl(iteratorZipPadding.ts, 65, 34)) ->k1 : Symbol(k1, Decl(iteratorZipPadding.ts, 44, 5)) - diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=true).types b/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=true).types deleted file mode 100644 index 431cddbbc31a7..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/iteratorZipPadding(exactoptionalpropertytypes=true).types +++ /dev/null @@ -1,549 +0,0 @@ -//// [tests/cases/compiler/iteratorZipPadding.ts] //// - -=== iteratorZipPadding.ts === -const a: [Iterable, ...Iterable[]] = [[1, 2], [3]]; ->a : [Iterable, ...Iterable[]] ->[[1, 2], [3]] : [number[], number[]] ->[1, 2] : number[] ->1 : 1 ->2 : 2 ->[3] : number[] ->3 : 3 - -const b = Iterator.zip(a, { mode: "longest", padding: [0] }).toArray(); ->b : [number, ...(number | undefined)[]][] ->Iterator.zip(a, { mode: "longest", padding: [0] }).toArray() : [number, ...(number | undefined)[]][] ->Iterator.zip(a, { mode: "longest", padding: [0] }).toArray : () => [number, ...(number | undefined)[]][] ->Iterator.zip(a, { mode: "longest", padding: [0] }) : IteratorObject<[number, ...(number | undefined)[]], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->a : [Iterable, ...Iterable[]] ->{ mode: "longest", padding: [0] } : { mode: "longest"; padding: [number]; } ->mode : "longest" ->"longest" : "longest" ->padding : [number] ->[0] : [number] ->0 : 0 ->toArray : () => [number, ...(number | undefined)[]][] - -const c: (number | undefined)[][] = b; ->c : (number | undefined)[][] ->b : [number, ...(number | undefined)[]][] - -const d: number[][] = b; ->d : number[][] ->b : [number, ...(number | undefined)[]][] - -const e: Record> = { a: [1], b: [2, 3] }; ->e : Record> ->{ a: [1], b: [2, 3] } : { a: number[]; b: number[]; } ->a : number[] ->[1] : number[] ->1 : 1 ->b : number[] ->[2, 3] : number[] ->2 : 2 ->3 : 3 - -const f = Iterator.zipKeyed(e, { mode: "longest", padding: {} }).toArray(); ->f : { [x: string]: number | undefined; }[] ->Iterator.zipKeyed(e, { mode: "longest", padding: {} }).toArray() : { [x: string]: number | undefined; }[] ->Iterator.zipKeyed(e, { mode: "longest", padding: {} }).toArray : () => { [x: string]: number | undefined; }[] ->Iterator.zipKeyed(e, { mode: "longest", padding: {} }) : IteratorObject<{ [x: string]: number | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->e : Record> ->{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } ->mode : "longest" ->"longest" : "longest" ->padding : {} ->{} : {} ->toArray : () => { [x: string]: number | undefined; }[] - -const g: Record[] = f; ->g : Record[] ->f : { [x: string]: number | undefined; }[] - -const h: Record[] = f; ->h : Record[] ->f : { [x: string]: number | undefined; }[] - -declare const i: Record; ->i : Record - -const j = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: i }).toArray(); ->j : { a: number | undefined; b: number | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: i }).toArray() : { a: number | undefined; b: number | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: i }).toArray : () => { a: number | undefined; b: number | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: i }) : IteratorObject<{ a: number | undefined; b: number | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ a: [1], b: [2, 3] } : { a: number[]; b: number[]; } ->a : number[] ->[1] : number[] ->1 : 1 ->b : number[] ->[2, 3] : number[] ->2 : 2 ->3 : 3 ->{ mode: "longest", padding: i } : { mode: "longest"; padding: Record; } ->mode : "longest" ->"longest" : "longest" ->padding : Record ->i : Record ->toArray : () => { a: number | undefined; b: number | undefined; }[] - -const k: { a: number | undefined; b: number | undefined; }[] = j; ->k : { a: number | undefined; b: number | undefined; }[] ->a : number | undefined ->b : number | undefined ->j : { a: number | undefined; b: number | undefined; }[] - -const l: { a: number; b: number; }[] = j; ->l : { a: number; b: number; }[] ->a : number ->b : number ->j : { a: number | undefined; b: number | undefined; }[] - -const m = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); ->m : [number, string][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray() : [number, string][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray : () => [number, string][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }) : IteratorObject<[number, string], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->[[1], ["a"]] : [number[], string[]] ->[1] : number[] ->1 : 1 ->["a"] : string[] ->"a" : "a" ->{ mode: "longest", padding: [0, ""] } : { mode: "longest"; padding: [number, string]; } ->mode : "longest" ->"longest" : "longest" ->padding : [number, string] ->[0, ""] : [number, string] ->0 : 0 ->"" : "" ->toArray : () => [number, string][] - -const n: [number, string][] = m; ->n : [number, string][] ->m : [number, string][] - -const o = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); ->o : { a: number; b: string; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray() : { a: number; b: string; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray : () => { a: number; b: string; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }) : IteratorObject<{ a: number; b: string; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } ->a : number[] ->[1] : number[] ->1 : 1 ->b : string[] ->["a"] : string[] ->"a" : "a" ->{ mode: "longest", padding: { a: 0, b: "" } } : { mode: "longest"; padding: { a: number; b: string; }; } ->mode : "longest" ->"longest" : "longest" ->padding : { a: number; b: string; } ->{ a: 0, b: "" } : { a: number; b: string; } ->a : number ->0 : 0 ->b : string ->"" : "" ->toArray : () => { a: number; b: string; }[] - -const p: { a: number; b: string; }[] = o; ->p : { a: number; b: string; }[] ->a : number ->b : string ->o : { a: number; b: string; }[] - -const q = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); ->q : [number, string | undefined][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray() : [number, string | undefined][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray : () => [number, string | undefined][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }) : IteratorObject<[number, string | undefined], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->[[1], ["a"]] : [number[], string[]] ->[1] : number[] ->1 : 1 ->["a"] : string[] ->"a" : "a" ->{ mode: "longest", padding: [0] } : { mode: "longest"; padding: [number]; } ->mode : "longest" ->"longest" : "longest" ->padding : [number] ->[0] : [number] ->0 : 0 ->toArray : () => [number, string | undefined][] - -const r: [number | undefined, string | undefined][] = q; ->r : [number | undefined, string | undefined][] ->q : [number, string | undefined][] - -const s: [number, string][] = q; ->s : [number, string][] ->q : [number, string | undefined][] - -const t = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); ->t : { a: number; b: string | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray() : { a: number; b: string | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray : () => { a: number; b: string | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }) : IteratorObject<{ a: number; b: string | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } ->a : number[] ->[1] : number[] ->1 : 1 ->b : string[] ->["a"] : string[] ->"a" : "a" ->{ mode: "longest", padding: { a: 0 } } : { mode: "longest"; padding: { a: number; }; } ->mode : "longest" ->"longest" : "longest" ->padding : { a: number; } ->{ a: 0 } : { a: number; } ->a : number ->0 : 0 ->toArray : () => { a: number; b: string | undefined; }[] - -const u: { a: number | undefined; b: string | undefined; }[] = t; ->u : { a: number | undefined; b: string | undefined; }[] ->a : number | undefined ->b : string | undefined ->t : { a: number; b: string | undefined; }[] - -const v: { a: number; b: string; }[] = t; ->v : { a: number; b: string; }[] ->a : number ->b : string ->t : { a: number; b: string | undefined; }[] - -declare const w: readonly [number, string]; ->w : readonly [number, string] - -const x: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: w }).toArray(); ->x : [number, string][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: w }).toArray() : [number, string][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: w }).toArray : () => [number, string][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: w }) : IteratorObject<[number, string], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->[[1], ["a"]] : [number[], string[]] ->[1] : number[] ->1 : 1 ->["a"] : string[] ->"a" : "a" ->{ mode: "longest", padding: w } : { mode: "longest"; padding: readonly [number, string]; } ->mode : "longest" ->"longest" : "longest" ->padding : readonly [number, string] ->w : readonly [number, string] ->toArray : () => [number, string][] - -declare const y: [number, string?]; ->y : [number, string?] - -const z = Iterator.zip([[1], ["a"]], { mode: "longest", padding: y }).toArray(); ->z : [number, string | undefined][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: y }).toArray() : [number, string | undefined][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: y }).toArray : () => [number, string | undefined][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: y }) : IteratorObject<[number, string | undefined], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->[[1], ["a"]] : [number[], string[]] ->[1] : number[] ->1 : 1 ->["a"] : string[] ->"a" : "a" ->{ mode: "longest", padding: y } : { mode: "longest"; padding: [number, string?]; } ->mode : "longest" ->"longest" : "longest" ->padding : [number, string?] ->y : [number, string?] ->toArray : () => [number, string | undefined][] - -const a1: [number, string][] = z; ->a1 : [number, string][] ->z : [number, string | undefined][] - -declare const b1: [Iterable] | [Iterable, Iterable]; ->b1 : [Iterable] | [Iterable, Iterable] - -const c1 = Iterator.zip(b1, { mode: "longest", padding: [0] }).toArray(); ->c1 : ([number] | [number, number | undefined])[] ->Iterator.zip(b1, { mode: "longest", padding: [0] }).toArray() : ([number] | [number, number | undefined])[] ->Iterator.zip(b1, { mode: "longest", padding: [0] }).toArray : () => ([number] | [number, number | undefined])[] ->Iterator.zip(b1, { mode: "longest", padding: [0] }) : IteratorObject<[number] | [number, number | undefined], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->b1 : [Iterable] | [Iterable, Iterable] ->{ mode: "longest", padding: [0] } : { mode: "longest"; padding: [number]; } ->mode : "longest" ->"longest" : "longest" ->padding : [number] ->[0] : [number] ->0 : 0 ->toArray : () => ([number] | [number, number | undefined])[] - -const d1: number[][] = c1; ->d1 : number[][] ->c1 : ([number] | [number, number | undefined])[] - -declare const e1: { a: Iterable; } | { b: Iterable; }; ->e1 : { a: Iterable; } | { b: Iterable; } ->a : Iterable ->b : Iterable - -const f1 = Iterator.zipKeyed(e1, { mode: "longest", padding: { a: 0 } }).toArray(); ->f1 : ({ a: number; } | { b: string | undefined; })[] ->Iterator.zipKeyed(e1, { mode: "longest", padding: { a: 0 } }).toArray() : ({ a: number; } | { b: string | undefined; })[] ->Iterator.zipKeyed(e1, { mode: "longest", padding: { a: 0 } }).toArray : () => ({ a: number; } | { b: string | undefined; })[] ->Iterator.zipKeyed(e1, { mode: "longest", padding: { a: 0 } }) : IteratorObject<{ a: number; } | { b: string | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->e1 : { a: Iterable; } | { b: Iterable; } ->{ mode: "longest", padding: { a: 0 } } : { mode: "longest"; padding: { a: number; }; } ->mode : "longest" ->"longest" : "longest" ->padding : { a: number; } ->{ a: 0 } : { a: number; } ->a : number ->0 : 0 ->toArray : () => ({ a: number; } | { b: string | undefined; })[] - -const g1: ({ a: number; } | { b: string; })[] = f1; ->g1 : ({ a: number; } | { b: string; })[] ->a : number ->b : string ->f1 : ({ a: number; } | { b: string | undefined; })[] - -declare const h1: { a: number; } | { b: string; }; ->h1 : { a: number; } | { b: string; } ->a : number ->b : string - -const i1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: h1 }).toArray(); ->i1 : { a: number | undefined; b: string | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: h1 }).toArray() : { a: number | undefined; b: string | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: h1 }).toArray : () => { a: number | undefined; b: string | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: h1 }) : IteratorObject<{ a: number | undefined; b: string | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } ->a : number[] ->[1] : number[] ->1 : 1 ->b : string[] ->["a"] : string[] ->"a" : "a" ->{ mode: "longest", padding: h1 } : { mode: "longest"; padding: { a: number; } | { b: string; }; } ->mode : "longest" ->"longest" : "longest" ->padding : { a: number; } | { b: string; } ->h1 : { a: number; } | { b: string; } ->toArray : () => { a: number | undefined; b: string | undefined; }[] - -const j1: { a: number; b: string; }[] = i1; ->j1 : { a: number; b: string; }[] ->a : number ->b : string ->i1 : { a: number | undefined; b: string | undefined; }[] - -const k1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); ->k1 : { a: number | undefined; b: number; }[] ->Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray() : { a: number | undefined; b: number; }[] ->Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray : () => { a: number | undefined; b: number; }[] ->Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }) : IteratorObject<{ a: number | undefined; b: number; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ a: [1], b: [2] } : { a: number[]; b: number[]; } ->a : number[] ->[1] : number[] ->1 : 1 ->b : number[] ->[2] : number[] ->2 : 2 ->{ mode: "longest", padding: { a: undefined, b: 0 } } : { mode: "longest"; padding: { a: undefined; b: number; }; } ->mode : "longest" ->"longest" : "longest" ->padding : { a: undefined; b: number; } ->{ a: undefined, b: 0 } : { a: undefined; b: number; } ->a : undefined ->undefined : undefined ->b : number ->0 : 0 ->toArray : () => { a: number | undefined; b: number; }[] - -const l1: { a: number; b: number; }[] = k1; ->l1 : { a: number; b: number; }[] ->a : number ->b : number ->k1 : { a: number | undefined; b: number; }[] - -declare const m1: { [K in `a${string}`]: Iterable; }; ->m1 : { [x: `a${string}`]: Iterable; } - -const n1 = Iterator.zipKeyed(m1, { mode: "longest", padding: {} }).toArray(); ->n1 : { [x: `a${string}`]: number | undefined; }[] ->Iterator.zipKeyed(m1, { mode: "longest", padding: {} }).toArray() : { [x: `a${string}`]: number | undefined; }[] ->Iterator.zipKeyed(m1, { mode: "longest", padding: {} }).toArray : () => { [x: `a${string}`]: number | undefined; }[] ->Iterator.zipKeyed(m1, { mode: "longest", padding: {} }) : IteratorObject<{ [x: `a${string}`]: number | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->m1 : { [x: `a${string}`]: Iterable; } ->{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } ->mode : "longest" ->"longest" : "longest" ->padding : {} ->{} : {} ->toArray : () => { [x: `a${string}`]: number | undefined; }[] - -const o1: { [K in `a${string}`]: number; }[] = n1; ->o1 : { [x: `a${string}`]: number; }[] ->n1 : { [x: `a${string}`]: number | undefined; }[] - -declare const p1: unique symbol; ->p1 : unique symbol - -const q1: { [p1]: number; }[] = Iterator.zipKeyed({ [p1]: [1] }, { mode: "longest", padding: { [p1]: 0 } }).toArray(); ->q1 : { [p1]: number; }[] ->[p1] : number ->p1 : unique symbol ->Iterator.zipKeyed({ [p1]: [1] }, { mode: "longest", padding: { [p1]: 0 } }).toArray() : { [p1]: number; }[] ->Iterator.zipKeyed({ [p1]: [1] }, { mode: "longest", padding: { [p1]: 0 } }).toArray : () => { [p1]: number; }[] ->Iterator.zipKeyed({ [p1]: [1] }, { mode: "longest", padding: { [p1]: 0 } }) : IteratorObject<{ [p1]: number; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ [p1]: [1] } : { [p1]: number[]; } ->[p1] : number[] ->p1 : unique symbol ->[1] : number[] ->1 : 1 ->{ mode: "longest", padding: { [p1]: 0 } } : { mode: "longest"; padding: { [p1]: number; }; } ->mode : "longest" ->"longest" : "longest" ->padding : { [p1]: number; } ->{ [p1]: 0 } : { [p1]: number; } ->[p1] : number ->p1 : unique symbol ->0 : 0 ->toArray : () => { [p1]: number; }[] - -declare const r1: Record & { a: number; }; ->r1 : Record & { a: number; } ->a : number - -const s1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: r1 }).toArray(); ->s1 : { a: number; b: number | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: r1 }).toArray() : { a: number; b: number | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: r1 }).toArray : () => { a: number; b: number | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: r1 }) : IteratorObject<{ a: number; b: number | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; } ->{ a: [1], b: [2] } : { a: number[]; b: number[]; } ->a : number[] ->[1] : number[] ->1 : 1 ->b : number[] ->[2] : number[] ->2 : 2 ->{ mode: "longest", padding: r1 } : { mode: "longest"; padding: Record & { a: number; }; } ->mode : "longest" ->"longest" : "longest" ->padding : Record & { a: number; } ->r1 : Record & { a: number; } ->toArray : () => { a: number; b: number | undefined; }[] - -const t1: { a: number; b: number | undefined; }[] = s1; ->t1 : { a: number; b: number | undefined; }[] ->a : number ->b : number | undefined ->s1 : { a: number; b: number | undefined; }[] - -const u1: { a: number; b: number; }[] = s1; ->u1 : { a: number; b: number; }[] ->a : number ->b : number ->s1 : { a: number; b: number | undefined; }[] - -declare const v1: [number] | [number, string]; ->v1 : [number] | [number, string] - -const w1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: v1 }).toArray(); ->w1 : [number, string | undefined][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: v1 }).toArray() : [number, string | undefined][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: v1 }).toArray : () => [number, string | undefined][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: v1 }) : IteratorObject<[number, string | undefined], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->[[1], ["a"]] : [number[], string[]] ->[1] : number[] ->1 : 1 ->["a"] : string[] ->"a" : "a" ->{ mode: "longest", padding: v1 } : { mode: "longest"; padding: [number] | [number, string]; } ->mode : "longest" ->"longest" : "longest" ->padding : [number] | [number, string] ->v1 : [number] | [number, string] ->toArray : () => [number, string | undefined][] - -const x1: [number, string | undefined][] = w1; ->x1 : [number, string | undefined][] ->w1 : [number, string | undefined][] - -const y1: [number, string][] = w1; ->y1 : [number, string][] ->w1 : [number, string | undefined][] - -const z1: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); ->z1 : [number | undefined, number][] ->Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray() : [number | undefined, number][] ->Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray : () => [number | undefined, number][] ->Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }) : IteratorObject<[number | undefined, number], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->[[1], [2]] : [number[], number[]] ->[1] : number[] ->1 : 1 ->[2] : number[] ->2 : 2 ->{ mode: "longest", padding: [undefined, 0] } : { mode: "longest"; padding: [undefined, number]; } ->mode : "longest" ->"longest" : "longest" ->padding : [undefined, number] ->[undefined, 0] : [undefined, number] ->undefined : undefined ->0 : 0 ->toArray : () => [number | undefined, number][] - -const a2: { a: number | undefined; b: number; }[] = k1; ->a2 : { a: number | undefined; b: number; }[] ->a : number | undefined ->b : number ->k1 : { a: number | undefined; b: number; }[] - diff --git a/tsc/testdata/tests/cases/compiler/iteratorConstructorAugmentation.ts b/tsc/testdata/tests/cases/compiler/iteratorConstructorAugmentation.ts new file mode 100644 index 0000000000000..bee673b8bb220 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/iteratorConstructorAugmentation.ts @@ -0,0 +1,21 @@ +// @target: es2015 +// @lib: es2015, es2025.iterator +// @strict: true +// @declaration: true + +interface IteratorConstructor { + f(): void; +} + +declare const a: Iterator; +declare const b: Iterable; + +const c: IteratorObject = Iterator.from(a); +const d: IteratorObject = Iterator.from(b); +const e = Iterator.from; +const f = Iterator.from; + +Iterator.f(); + +const g: IteratorObject = Iterator.from(a); +Iterator.from(1); diff --git a/tsc/testdata/tests/cases/compiler/iteratorZip.ts b/tsc/testdata/tests/cases/compiler/iteratorZip.ts index 46c7549670eb9..7b34ef3d5eb61 100644 --- a/tsc/testdata/tests/cases/compiler/iteratorZip.ts +++ b/tsc/testdata/tests/cases/compiler/iteratorZip.ts @@ -1,6 +1,8 @@ // @target: esnext // @lib: es2015, esnext.iterator // @strict: true +// @exactOptionalPropertyTypes: true, false +// @declaration: true declare const key: unique symbol; @@ -78,3 +80,190 @@ const emptyKeyedLongest: never[] = Iterator.zipKeyed({}, { mode: "longest", padd declare const unionInputs: { a: Iterable; } | { b: Iterator; }; const unionRows: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(unionInputs).toArray(); + +// Inputs + +Iterator.zip("ab"); +Iterator.zip(["ab"]); +Iterator.zip(new Set(["ab"])); +Iterator.zipKeyed("ab"); +Iterator.zipKeyed({ a: "ab" }); +Iterator.zip([], { mode: "longest", padding: "ab" }); +Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); +Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); + +const a: [string][] = Iterator.zip([new String("ab")]).toArray(); +const b: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); +const c: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); + +const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); +const e: { a: number; }[] = d; +d[0].b; +const f: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); +const g: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); + +interface I { + readonly a: Iterable; + readonly b?: Iterator; + readonly c: Iterable | undefined; + readonly d?: undefined; +} +declare const h: I; +const i = Iterator.zipKeyed(h).toArray(); +const j: { a: number; b?: string; c?: boolean; }[] = i; +i[0].a = 2; +i[0].b = "a"; +i[0].c = true; +i[0].d; +const k: { a: number; c: boolean; }[] = i; +const l: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); + +declare const m: { a: Iterable; } | { b: Iterator; }; +const n: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(m).toArray(); +declare const o: { a: Iterable; } | { b: number; }; +Iterator.zipKeyed(o); +Iterator.zipKeyed(o, { mode: "longest" }); +Iterator.zipKeyed(o, { mode: "longest", padding: {} }); +declare const p: { a?: Iterable; } | { b: string; }; +Iterator.zipKeyed(p); +declare const q: { a: Iterable; } | { b: undefined; }; +const r: { a: number; }[] = Iterator.zipKeyed(q).toArray(); + +declare const s: unique symbol; +declare const t: { a: Iterable; [s]?: Iterable; }; +const u: { a: number; [s]?: string; }[] = Iterator.zipKeyed(t).toArray(); + +Iterator.zipKeyed({ a: [1], b: null }); +Iterator.zipKeyed({ a: [1], b: false }); +Iterator.zip([undefined]); + +declare const v: { a?: undefined; }; +const w: never[] = Iterator.zipKeyed(v).toArray(); +const x: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); +const y: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); + +function f1(a: Iterable) { + const b: { a: T; }[] = Iterator.zipKeyed({ a }).toArray(); + const c: [T][] = Iterator.zip([a]).toArray(); + return { b, c }; +} + +// Padding + +const paddingA: [Iterable, ...Iterable[]] = [[1, 2], [3]]; +const paddingB = Iterator.zip(paddingA, { mode: "longest", padding: [0] }).toArray(); +const paddingC: (number | undefined)[][] = paddingB; +const paddingD: number[][] = paddingB; + +const paddingE: Record> = { a: [1], b: [2, 3] }; +const paddingF = Iterator.zipKeyed(paddingE, { mode: "longest", padding: {} }).toArray(); +const paddingG: Record[] = paddingF; +const paddingH: Record[] = paddingF; + +declare const paddingI: Record; +const paddingJ = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: paddingI }).toArray(); +const paddingK: { a: number | undefined; b: number | undefined; }[] = paddingJ; +const paddingL: { a: number; b: number; }[] = paddingJ; + +const paddingM = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); +const paddingN: [number, string][] = paddingM; +const paddingO = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); +const paddingP: { a: number; b: string; }[] = paddingO; + +const paddingQ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); +const paddingR: [number | undefined, string | undefined][] = paddingQ; +const paddingS: [number, string][] = paddingQ; +const paddingT = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); +const paddingU: { a: number | undefined; b: string | undefined; }[] = paddingT; +const paddingV: { a: number; b: string; }[] = paddingT; + +declare const paddingW: readonly [number, string]; +const paddingX: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingW }).toArray(); +declare const paddingY: [number, string?]; +const paddingZ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY }).toArray(); +const paddingA1: [number, string][] = paddingZ; + +declare const paddingB1: [Iterable] | [Iterable, Iterable]; +const paddingC1 = Iterator.zip(paddingB1, { mode: "longest", padding: [0] }).toArray(); +const paddingD1: number[][] = paddingC1; +declare const paddingE1: { a: Iterable; } | { b: Iterable; }; +const paddingF1 = Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: 0 } }).toArray(); +const paddingG1: ({ a: number; } | { b: string; })[] = paddingF1; + +declare const paddingH1: { a: number; } | { b: string; }; +const paddingI1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: paddingH1 }).toArray(); +const paddingJ1: { a: number; b: string; }[] = paddingI1; + +const paddingK1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); +const paddingL1: { a: number; b: number; }[] = paddingK1; + +declare const paddingM1: { [K in `a${string}`]: Iterable; }; +const paddingN1 = Iterator.zipKeyed(paddingM1, { mode: "longest", padding: {} }).toArray(); +const paddingO1: { [K in `a${string}`]: number; }[] = paddingN1; + +declare const paddingP1: unique symbol; +const paddingQ1: { [paddingP1]: number; }[] = Iterator.zipKeyed({ [paddingP1]: [1] }, { mode: "longest", padding: { [paddingP1]: 0 } }).toArray(); + +declare const paddingR1: Record & { a: number; }; +const paddingS1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: paddingR1 }).toArray(); +const paddingT1: { a: number; b: number | undefined; }[] = paddingS1; +const paddingU1: { a: number; b: number; }[] = paddingS1; + +declare const paddingV1: [number] | [number, string]; +const paddingW1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingV1 }).toArray(); +const paddingX1: [number, string | undefined][] = paddingW1; +const paddingY1: [number, string][] = paddingW1; + +const paddingZ1: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); +const paddingA2: { a: number | undefined; b: number; }[] = paddingK1; + +// Own properties + +class InputsWithPrototypeMembers { + values = [1, 2]; + + get label() { + return "inputs"; + } + + describe() { + return this.label; + } +} + +const instance = new InputsWithPrototypeMembers(); +const inherited = Iterator.zipKeyed(instance).toArray(); +const inheritedStrict = Iterator.zipKeyed(instance, { mode: "strict" }).toArray(); +const inheritedLongest = Iterator.zipKeyed(instance, { mode: "longest" }).toArray(); +const inheritedPadded = Iterator.zipKeyed(instance, { mode: "longest", padding: { values: 0 } }).toArray(); + +const hiddenInputs = { values: [1, 2], label: "inputs" }; +Object.defineProperty(hiddenInputs, "label", { enumerable: false }); +const nonEnumerable = Iterator.zipKeyed(hiddenInputs).toArray(); +const nonEnumerablePadded = Iterator.zipKeyed(hiddenInputs, { mode: "longest", padding: { values: 0 } }).toArray(); + +// The same static shape can have an enumerable non-iterator property instead. +// Such inputs are accepted by the fallback and checked at runtime. +const enumerableInputs = { values: [1, 2], label: "inputs" }; +const enumerable = Iterator.zipKeyed(enumerableInputs).toArray(); + +// The array's length and methods are not enumerable own properties. +const arrayInputs = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); + +// The fallback must not claim that ignored properties exist on yielded objects. +const inheritedLabel: string = inherited[0].label; +const nonEnumerableLabel: string = nonEnumerable[0].label; + +// Precise record inference still handles symbol keys and padding. +declare const ownKey: unique symbol; +const precise: { values: number; [ownKey]: string; }[] = Iterator.zipKeyed({ values: [1], [ownKey]: ["a"] }).toArray(); +const preciseLongest: { values: number | undefined; }[] = Iterator.zipKeyed({ values: [1] }, { mode: "longest" }).toArray(); +const precisePadded: { values: number; }[] = Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: 0 } }).toArray(); +const emptyOwnProperties: never[] = Iterator.zipKeyed({}).toArray(); + +Iterator.zipKeyed(0); +Iterator.zipKeyed(null); +Iterator.zipKeyed(instance, { mode: "invalid" }); +Iterator.zipKeyed(instance, { mode: "shortest", padding: {} }); +Iterator.zipKeyed(instance, { mode: "longest", padding: 0 }); +Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: "invalid" } }); diff --git a/tsc/testdata/tests/cases/compiler/iteratorZipInputs.ts b/tsc/testdata/tests/cases/compiler/iteratorZipInputs.ts deleted file mode 100644 index 9f0959bdb1788..0000000000000 --- a/tsc/testdata/tests/cases/compiler/iteratorZipInputs.ts +++ /dev/null @@ -1,70 +0,0 @@ -// @target: esnext -// @lib: es2015, esnext.iterator -// @strict: true -// @exactOptionalPropertyTypes: true, false -// @declaration: true - -Iterator.zip("ab"); -Iterator.zip(["ab"]); -Iterator.zip(new Set(["ab"])); -Iterator.zipKeyed("ab"); -Iterator.zipKeyed({ a: "ab" }); -Iterator.zip([], { mode: "longest", padding: "ab" }); -Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); -Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); - -const a: [string][] = Iterator.zip([new String("ab")]).toArray(); -const b: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); -const c: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); - -const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); -const e: { a: number; }[] = d; -d[0].b; -const f: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); -const g: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); - -interface I { - readonly a: Iterable; - readonly b?: Iterator; - readonly c: Iterable | undefined; - readonly d?: undefined; -} -declare const h: I; -const i = Iterator.zipKeyed(h).toArray(); -const j: { a: number; b?: string; c?: boolean; }[] = i; -i[0].a = 2; -i[0].b = "a"; -i[0].c = true; -i[0].d; -const k: { a: number; c: boolean; }[] = i; -const l: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); - -declare const m: { a: Iterable; } | { b: Iterator; }; -const n: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(m).toArray(); -declare const o: { a: Iterable; } | { b: number; }; -Iterator.zipKeyed(o); -Iterator.zipKeyed(o, { mode: "longest" }); -Iterator.zipKeyed(o, { mode: "longest", padding: {} }); -declare const p: { a?: Iterable; } | { b: string; }; -Iterator.zipKeyed(p); -declare const q: { a: Iterable; } | { b: undefined; }; -const r: { a: number; }[] = Iterator.zipKeyed(q).toArray(); - -declare const s: unique symbol; -declare const t: { a: Iterable; [s]?: Iterable; }; -const u: { a: number; [s]?: string; }[] = Iterator.zipKeyed(t).toArray(); - -Iterator.zipKeyed({ a: [1], b: null }); -Iterator.zipKeyed({ a: [1], b: false }); -Iterator.zip([undefined]); - -declare const v: { a?: undefined; }; -const w: never[] = Iterator.zipKeyed(v).toArray(); -const x: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); -const y: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); - -function f1(a: Iterable) { - const b: { a: T; }[] = Iterator.zipKeyed({ a }).toArray(); - const c: [T][] = Iterator.zip([a]).toArray(); - return { b, c }; -} diff --git a/tsc/testdata/tests/cases/compiler/iteratorZipPadding.ts b/tsc/testdata/tests/cases/compiler/iteratorZipPadding.ts deleted file mode 100644 index 28a94f7ba69a4..0000000000000 --- a/tsc/testdata/tests/cases/compiler/iteratorZipPadding.ts +++ /dev/null @@ -1,72 +0,0 @@ -// @target: esnext -// @lib: es2015, esnext.iterator -// @strict: true -// @exactOptionalPropertyTypes: true, false -// @declaration: true - -const a: [Iterable, ...Iterable[]] = [[1, 2], [3]]; -const b = Iterator.zip(a, { mode: "longest", padding: [0] }).toArray(); -const c: (number | undefined)[][] = b; -const d: number[][] = b; - -const e: Record> = { a: [1], b: [2, 3] }; -const f = Iterator.zipKeyed(e, { mode: "longest", padding: {} }).toArray(); -const g: Record[] = f; -const h: Record[] = f; - -declare const i: Record; -const j = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: i }).toArray(); -const k: { a: number | undefined; b: number | undefined; }[] = j; -const l: { a: number; b: number; }[] = j; - -const m = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); -const n: [number, string][] = m; -const o = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); -const p: { a: number; b: string; }[] = o; - -const q = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); -const r: [number | undefined, string | undefined][] = q; -const s: [number, string][] = q; -const t = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); -const u: { a: number | undefined; b: string | undefined; }[] = t; -const v: { a: number; b: string; }[] = t; - -declare const w: readonly [number, string]; -const x: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: w }).toArray(); -declare const y: [number, string?]; -const z = Iterator.zip([[1], ["a"]], { mode: "longest", padding: y }).toArray(); -const a1: [number, string][] = z; - -declare const b1: [Iterable] | [Iterable, Iterable]; -const c1 = Iterator.zip(b1, { mode: "longest", padding: [0] }).toArray(); -const d1: number[][] = c1; -declare const e1: { a: Iterable; } | { b: Iterable; }; -const f1 = Iterator.zipKeyed(e1, { mode: "longest", padding: { a: 0 } }).toArray(); -const g1: ({ a: number; } | { b: string; })[] = f1; - -declare const h1: { a: number; } | { b: string; }; -const i1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: h1 }).toArray(); -const j1: { a: number; b: string; }[] = i1; - -const k1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); -const l1: { a: number; b: number; }[] = k1; - -declare const m1: { [K in `a${string}`]: Iterable; }; -const n1 = Iterator.zipKeyed(m1, { mode: "longest", padding: {} }).toArray(); -const o1: { [K in `a${string}`]: number; }[] = n1; - -declare const p1: unique symbol; -const q1: { [p1]: number; }[] = Iterator.zipKeyed({ [p1]: [1] }, { mode: "longest", padding: { [p1]: 0 } }).toArray(); - -declare const r1: Record & { a: number; }; -const s1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: r1 }).toArray(); -const t1: { a: number; b: number | undefined; }[] = s1; -const u1: { a: number; b: number; }[] = s1; - -declare const v1: [number] | [number, string]; -const w1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: v1 }).toArray(); -const x1: [number, string | undefined][] = w1; -const y1: [number, string][] = w1; - -const z1: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); -const a2: { a: number | undefined; b: number; }[] = k1; From c6dc9159aeff7861d2e37d3367cedb0047a087fc Mon Sep 17 00:00:00 2001 From: Oleksandr Tarasiuk Date: Thu, 1 Oct 2026 22:45:45 +0300 Subject: [PATCH 7/8] fix Iterator.zipKeyed inference --- .../bundled/libs/lib.esnext.iterator.d.ts | 17 +- .../compiler/iteratorChunks.errors.txt | 2 +- .../reference/compiler/iteratorChunks.js | 4 +- .../reference/compiler/iteratorChunks.symbols | 4 +- .../reference/compiler/iteratorChunks.types | 4 +- .../compiler/iteratorIncludes.errors.txt | 4 +- .../reference/compiler/iteratorIncludes.js | 8 +- .../compiler/iteratorIncludes.symbols | 8 +- .../reference/compiler/iteratorIncludes.types | 8 +- .../compiler/iteratorJoin.errors.txt | 4 +- .../reference/compiler/iteratorJoin.js | 8 +- .../reference/compiler/iteratorJoin.symbols | 8 +- .../reference/compiler/iteratorJoin.types | 8 +- ...actoptionalpropertytypes=false).errors.txt | 598 +++--- ...orZip(exactoptionalpropertytypes=false).js | 948 +++++----- ...(exactoptionalpropertytypes=false).symbols | 1475 ++++++++------- ...ip(exactoptionalpropertytypes=false).types | 1680 +++++++++-------- ...xactoptionalpropertytypes=true).errors.txt | 602 +++--- ...torZip(exactoptionalpropertytypes=true).js | 948 +++++----- ...p(exactoptionalpropertytypes=true).symbols | 1475 ++++++++------- ...Zip(exactoptionalpropertytypes=true).types | 1680 +++++++++-------- ...tions(exactoptionalpropertytypes=false).js | 108 ++ ...(exactoptionalpropertytypes=false).symbols | 173 ++ ...ns(exactoptionalpropertytypes=false).types | 210 +++ ...ations(exactoptionalpropertytypes=true).js | 108 ++ ...s(exactoptionalpropertytypes=true).symbols | 173 ++ ...ons(exactoptionalpropertytypes=true).types | 210 +++ .../tests/cases/compiler/iteratorChunks.ts | 2 +- .../tests/cases/compiler/iteratorIncludes.ts | 4 +- .../tests/cases/compiler/iteratorJoin.ts | 4 +- .../tests/cases/compiler/iteratorZip.ts | 366 ++-- .../cases/compiler/iteratorZipDeclarations.ts | 41 + 32 files changed, 6165 insertions(+), 4727 deletions(-) create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=false).js create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=false).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=false).types create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=true).js create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=true).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=true).types create mode 100644 tsc/testdata/tests/cases/compiler/iteratorZipDeclarations.ts diff --git a/tsc/internal/bundled/libs/lib.esnext.iterator.d.ts b/tsc/internal/bundled/libs/lib.esnext.iterator.d.ts index c2ebb7000b711..94154a585b6f4 100644 --- a/tsc/internal/bundled/libs/lib.esnext.iterator.d.ts +++ b/tsc/internal/bundled/libs/lib.esnext.iterator.d.ts @@ -62,21 +62,22 @@ type IteratorZipPaddingKeys = keyof { [K in keyof T as {} extends Pick ? never : K]: unknown; }; +type IteratorZipValue = + | IteratorYield + | (K extends keyof TPadding ? TPadding[K] : never) + | (K extends IteratorZipPaddingKeys ? never : TExtra); + type IteratorZipResult = { - -readonly [K in keyof T]: IteratorYield | (K extends keyof TPadding ? TPadding[K] : never) | (K extends IteratorZipPaddingKeys ? never : TExtra); + -readonly [K in keyof T]: IteratorZipValue; }; type IteratorZipKeyedInput = { [K in T extends unknown ? keyof T : never]?: IteratorInput | undefined; }; -type IteratorZipKeyedResult = T extends Partial> ? never - : IteratorZipResult< - { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & - { [K in keyof T as undefined extends T[K] ? T[K] extends undefined ? never : K : never]?: T[K]; }, - TExtra, - TPadding - >; +type IteratorZipKeyedResult = T extends Partial> ? keyof T extends never ? Record : never + : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: IteratorZipValue; } & + { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends undefined ? never : K : never]?: IteratorZipValue; }; declare global { interface IteratorObject { diff --git a/tsc/testdata/baselines/reference/compiler/iteratorChunks.errors.txt b/tsc/testdata/baselines/reference/compiler/iteratorChunks.errors.txt index 1058ea5afa59e..afa61835456fd 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorChunks.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/iteratorChunks.errors.txt @@ -2,7 +2,7 @@ iteratorChunks.ts(3,33): error TS2345: Argument of type 'string' is not assignab ==== iteratorChunks.ts (1 errors) ==== - const chunks: number[][] = Iterator.from([1, 2, 3]).chunks(2).toArray(); + const a: number[][] = Iterator.from([1, 2, 3]).chunks(2).toArray(); Iterator.from([1, 2, 3]).chunks("2"); ~~~ diff --git a/tsc/testdata/baselines/reference/compiler/iteratorChunks.js b/tsc/testdata/baselines/reference/compiler/iteratorChunks.js index 276d3590cd6e5..48f57dd902cf9 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorChunks.js +++ b/tsc/testdata/baselines/reference/compiler/iteratorChunks.js @@ -1,12 +1,12 @@ //// [tests/cases/compiler/iteratorChunks.ts] //// //// [iteratorChunks.ts] -const chunks: number[][] = Iterator.from([1, 2, 3]).chunks(2).toArray(); +const a: number[][] = Iterator.from([1, 2, 3]).chunks(2).toArray(); Iterator.from([1, 2, 3]).chunks("2"); //// [iteratorChunks.js] "use strict"; -const chunks = Iterator.from([1, 2, 3]).chunks(2).toArray(); +const a = Iterator.from([1, 2, 3]).chunks(2).toArray(); Iterator.from([1, 2, 3]).chunks("2"); diff --git a/tsc/testdata/baselines/reference/compiler/iteratorChunks.symbols b/tsc/testdata/baselines/reference/compiler/iteratorChunks.symbols index da7283633fad3..e24c9f08e741a 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorChunks.symbols +++ b/tsc/testdata/baselines/reference/compiler/iteratorChunks.symbols @@ -1,8 +1,8 @@ //// [tests/cases/compiler/iteratorChunks.ts] //// === iteratorChunks.ts === -const chunks: number[][] = Iterator.from([1, 2, 3]).chunks(2).toArray(); ->chunks : Symbol(chunks, Decl(iteratorChunks.ts, 0, 5)) +const a: number[][] = Iterator.from([1, 2, 3]).chunks(2).toArray(); +>a : Symbol(a, Decl(iteratorChunks.ts, 0, 5)) >Iterator.from([1, 2, 3]).chunks(2).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.from([1, 2, 3]).chunks : Symbol(IteratorObject.chunks, Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator.from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) diff --git a/tsc/testdata/baselines/reference/compiler/iteratorChunks.types b/tsc/testdata/baselines/reference/compiler/iteratorChunks.types index a70cd739067c4..8e3c36f5af42a 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorChunks.types +++ b/tsc/testdata/baselines/reference/compiler/iteratorChunks.types @@ -1,8 +1,8 @@ //// [tests/cases/compiler/iteratorChunks.ts] //// === iteratorChunks.ts === -const chunks: number[][] = Iterator.from([1, 2, 3]).chunks(2).toArray(); ->chunks : number[][] +const a: number[][] = Iterator.from([1, 2, 3]).chunks(2).toArray(); +>a : number[][] >Iterator.from([1, 2, 3]).chunks(2).toArray() : number[][] >Iterator.from([1, 2, 3]).chunks(2).toArray : () => number[][] >Iterator.from([1, 2, 3]).chunks(2) : IteratorObject diff --git a/tsc/testdata/baselines/reference/compiler/iteratorIncludes.errors.txt b/tsc/testdata/baselines/reference/compiler/iteratorIncludes.errors.txt index 31de09d8bc8e0..294bb1aa8e035 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorIncludes.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/iteratorIncludes.errors.txt @@ -3,8 +3,8 @@ iteratorIncludes.ts(6,38): error TS2345: Argument of type 'string' is not assign ==== iteratorIncludes.ts (2 errors) ==== - const includes: boolean = Iterator.from([1, 2, 3]).includes(2); - const includesAfterSkipping: boolean = Iterator.from([1, 2, 3]).includes(2, 1); + const a: boolean = Iterator.from([1, 2, 3]).includes(2); + const b: boolean = Iterator.from([1, 2, 3]).includes(2, 1); Iterator.from([1, 2, 3]).includes("1"); ~~~ diff --git a/tsc/testdata/baselines/reference/compiler/iteratorIncludes.js b/tsc/testdata/baselines/reference/compiler/iteratorIncludes.js index 92d42f4785296..0b1020360fa61 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorIncludes.js +++ b/tsc/testdata/baselines/reference/compiler/iteratorIncludes.js @@ -1,8 +1,8 @@ //// [tests/cases/compiler/iteratorIncludes.ts] //// //// [iteratorIncludes.ts] -const includes: boolean = Iterator.from([1, 2, 3]).includes(2); -const includesAfterSkipping: boolean = Iterator.from([1, 2, 3]).includes(2, 1); +const a: boolean = Iterator.from([1, 2, 3]).includes(2); +const b: boolean = Iterator.from([1, 2, 3]).includes(2, 1); Iterator.from([1, 2, 3]).includes("1"); @@ -11,7 +11,7 @@ Iterator.from([1, 2, 3]).includes(2, "1"); //// [iteratorIncludes.js] "use strict"; -const includes = Iterator.from([1, 2, 3]).includes(2); -const includesAfterSkipping = Iterator.from([1, 2, 3]).includes(2, 1); +const a = Iterator.from([1, 2, 3]).includes(2); +const b = Iterator.from([1, 2, 3]).includes(2, 1); Iterator.from([1, 2, 3]).includes("1"); Iterator.from([1, 2, 3]).includes(2, "1"); diff --git a/tsc/testdata/baselines/reference/compiler/iteratorIncludes.symbols b/tsc/testdata/baselines/reference/compiler/iteratorIncludes.symbols index e1d0affa5aa76..0b04353f4d5fb 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorIncludes.symbols +++ b/tsc/testdata/baselines/reference/compiler/iteratorIncludes.symbols @@ -1,16 +1,16 @@ //// [tests/cases/compiler/iteratorIncludes.ts] //// === iteratorIncludes.ts === -const includes: boolean = Iterator.from([1, 2, 3]).includes(2); ->includes : Symbol(includes, Decl(iteratorIncludes.ts, 0, 5)) +const a: boolean = Iterator.from([1, 2, 3]).includes(2); +>a : Symbol(a, Decl(iteratorIncludes.ts, 0, 5)) >Iterator.from([1, 2, 3]).includes : Symbol(IteratorObject.includes, Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator.from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) >includes : Symbol(IteratorObject.includes, Decl(lib.esnext.iterator.d.ts, --, --)) -const includesAfterSkipping: boolean = Iterator.from([1, 2, 3]).includes(2, 1); ->includesAfterSkipping : Symbol(includesAfterSkipping, Decl(iteratorIncludes.ts, 1, 5)) +const b: boolean = Iterator.from([1, 2, 3]).includes(2, 1); +>b : Symbol(b, Decl(iteratorIncludes.ts, 1, 5)) >Iterator.from([1, 2, 3]).includes : Symbol(IteratorObject.includes, Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator.from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) diff --git a/tsc/testdata/baselines/reference/compiler/iteratorIncludes.types b/tsc/testdata/baselines/reference/compiler/iteratorIncludes.types index 9883553132cea..5e3ca1f848e5d 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorIncludes.types +++ b/tsc/testdata/baselines/reference/compiler/iteratorIncludes.types @@ -1,8 +1,8 @@ //// [tests/cases/compiler/iteratorIncludes.ts] //// === iteratorIncludes.ts === -const includes: boolean = Iterator.from([1, 2, 3]).includes(2); ->includes : boolean +const a: boolean = Iterator.from([1, 2, 3]).includes(2); +>a : boolean >Iterator.from([1, 2, 3]).includes(2) : boolean >Iterator.from([1, 2, 3]).includes : (searchElement: number, skippedElements?: number) => boolean >Iterator.from([1, 2, 3]) : IteratorObject @@ -16,8 +16,8 @@ const includes: boolean = Iterator.from([1, 2, 3]).includes(2); >includes : (searchElement: number, skippedElements?: number) => boolean >2 : 2 -const includesAfterSkipping: boolean = Iterator.from([1, 2, 3]).includes(2, 1); ->includesAfterSkipping : boolean +const b: boolean = Iterator.from([1, 2, 3]).includes(2, 1); +>b : boolean >Iterator.from([1, 2, 3]).includes(2, 1) : boolean >Iterator.from([1, 2, 3]).includes : (searchElement: number, skippedElements?: number) => boolean >Iterator.from([1, 2, 3]) : IteratorObject diff --git a/tsc/testdata/baselines/reference/compiler/iteratorJoin.errors.txt b/tsc/testdata/baselines/reference/compiler/iteratorJoin.errors.txt index b0f965b138061..342e43b80f24f 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorJoin.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/iteratorJoin.errors.txt @@ -2,8 +2,8 @@ iteratorJoin.ts(4,31): error TS2345: Argument of type 'number' is not assignable ==== iteratorJoin.ts (1 errors) ==== - const joined: string = Iterator.from([1, 2, 3]).join("-"); - const joinedWithDefaultSeparator: string = Iterator.from([1, 2, 3]).join(); + const a: string = Iterator.from([1, 2, 3]).join("-"); + const b: string = Iterator.from([1, 2, 3]).join(); Iterator.from([1, 2, 3]).join(0); ~ diff --git a/tsc/testdata/baselines/reference/compiler/iteratorJoin.js b/tsc/testdata/baselines/reference/compiler/iteratorJoin.js index 128b43c5b193d..a747bb9d0141b 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorJoin.js +++ b/tsc/testdata/baselines/reference/compiler/iteratorJoin.js @@ -1,14 +1,14 @@ //// [tests/cases/compiler/iteratorJoin.ts] //// //// [iteratorJoin.ts] -const joined: string = Iterator.from([1, 2, 3]).join("-"); -const joinedWithDefaultSeparator: string = Iterator.from([1, 2, 3]).join(); +const a: string = Iterator.from([1, 2, 3]).join("-"); +const b: string = Iterator.from([1, 2, 3]).join(); Iterator.from([1, 2, 3]).join(0); //// [iteratorJoin.js] "use strict"; -const joined = Iterator.from([1, 2, 3]).join("-"); -const joinedWithDefaultSeparator = Iterator.from([1, 2, 3]).join(); +const a = Iterator.from([1, 2, 3]).join("-"); +const b = Iterator.from([1, 2, 3]).join(); Iterator.from([1, 2, 3]).join(0); diff --git a/tsc/testdata/baselines/reference/compiler/iteratorJoin.symbols b/tsc/testdata/baselines/reference/compiler/iteratorJoin.symbols index 94c7ac9cbd5c1..4108ec495a362 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorJoin.symbols +++ b/tsc/testdata/baselines/reference/compiler/iteratorJoin.symbols @@ -1,16 +1,16 @@ //// [tests/cases/compiler/iteratorJoin.ts] //// === iteratorJoin.ts === -const joined: string = Iterator.from([1, 2, 3]).join("-"); ->joined : Symbol(joined, Decl(iteratorJoin.ts, 0, 5)) +const a: string = Iterator.from([1, 2, 3]).join("-"); +>a : Symbol(a, Decl(iteratorJoin.ts, 0, 5)) >Iterator.from([1, 2, 3]).join : Symbol(IteratorObject.join, Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator.from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) >join : Symbol(IteratorObject.join, Decl(lib.esnext.iterator.d.ts, --, --)) -const joinedWithDefaultSeparator: string = Iterator.from([1, 2, 3]).join(); ->joinedWithDefaultSeparator : Symbol(joinedWithDefaultSeparator, Decl(iteratorJoin.ts, 1, 5)) +const b: string = Iterator.from([1, 2, 3]).join(); +>b : Symbol(b, Decl(iteratorJoin.ts, 1, 5)) >Iterator.from([1, 2, 3]).join : Symbol(IteratorObject.join, Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator.from : Symbol(IteratorConstructor.from, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) diff --git a/tsc/testdata/baselines/reference/compiler/iteratorJoin.types b/tsc/testdata/baselines/reference/compiler/iteratorJoin.types index cad93dd3c8210..2d43772210222 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorJoin.types +++ b/tsc/testdata/baselines/reference/compiler/iteratorJoin.types @@ -1,8 +1,8 @@ //// [tests/cases/compiler/iteratorJoin.ts] //// === iteratorJoin.ts === -const joined: string = Iterator.from([1, 2, 3]).join("-"); ->joined : string +const a: string = Iterator.from([1, 2, 3]).join("-"); +>a : string >Iterator.from([1, 2, 3]).join("-") : string >Iterator.from([1, 2, 3]).join : (separator?: string) => string >Iterator.from([1, 2, 3]) : IteratorObject @@ -16,8 +16,8 @@ const joined: string = Iterator.from([1, 2, 3]).join("-"); >join : (separator?: string) => string >"-" : "-" -const joinedWithDefaultSeparator: string = Iterator.from([1, 2, 3]).join(); ->joinedWithDefaultSeparator : string +const b: string = Iterator.from([1, 2, 3]).join(); +>b : string >Iterator.from([1, 2, 3]).join() : string >Iterator.from([1, 2, 3]).join : (separator?: string) => string >Iterator.from([1, 2, 3]) : IteratorObject diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).errors.txt b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).errors.txt index 06d9ee80ef1aa..e763ab7eda746 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).errors.txt @@ -17,11 +17,11 @@ iteratorZip.ts(68,14): error TS2769: No overload matches this call. The last overload gave the following error. Argument of type 'number' is not assignable to parameter of type 'Iterable> & object'. Type 'number' is not assignable to type 'Iterable>'. -iteratorZip.ts(80,14): error TS2769: No overload matches this call. +iteratorZip.ts(78,14): error TS2769: No overload matches this call. The last overload gave the following error. Argument of type 'string' is not assignable to parameter of type 'Iterable> & object'. Type 'string' is not assignable to type 'Iterable>'. -iteratorZip.ts(81,14): error TS2769: No overload matches this call. +iteratorZip.ts(79,14): error TS2769: No overload matches this call. The last overload gave the following error. Argument of type 'string[]' is not assignable to parameter of type 'Iterable> & object'. Type 'string[]' is not assignable to type 'Iterable>'. @@ -30,7 +30,7 @@ iteratorZip.ts(81,14): error TS2769: No overload matches this call. Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>'. Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>'. Type 'string' is not assignable to type 'IteratorInput'. -iteratorZip.ts(82,14): error TS2769: No overload matches this call. +iteratorZip.ts(80,14): error TS2769: No overload matches this call. The last overload gave the following error. Argument of type 'Set' is not assignable to parameter of type 'Iterable> & object'. Type 'Set' is not assignable to type 'Iterable>'. @@ -39,28 +39,28 @@ iteratorZip.ts(82,14): error TS2769: No overload matches this call. Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>'. Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>'. Type 'string' is not assignable to type 'IteratorInput'. -iteratorZip.ts(83,19): error TS2769: No overload matches this call. +iteratorZip.ts(81,19): error TS2769: No overload matches this call. The last overload gave the following error. Argument of type '"ab"' is not assignable to parameter of type 'never'. -iteratorZip.ts(85,37): error TS2769: No overload matches this call. +iteratorZip.ts(83,37): error TS2769: No overload matches this call. The last overload gave the following error. Type 'string' is not assignable to type 'Iterable & object'. Type 'string' is not assignable to type 'Iterable'. -iteratorZip.ts(86,42): error TS2769: No overload matches this call. +iteratorZip.ts(84,42): error TS2769: No overload matches this call. The last overload gave the following error. Type 'string' is not assignable to type 'Iterable & object'. Type 'string' is not assignable to type 'object'. -iteratorZip.ts(87,19): error TS2769: No overload matches this call. +iteratorZip.ts(85,19): error TS2769: No overload matches this call. The last overload gave the following error. Argument of type '{}' is not assignable to parameter of type 'never'. -iteratorZip.ts(95,6): error TS2339: Property 'b' does not exist on type 'IteratorZipResult<{ a: number[]; } & {}, never, {}>'. -iteratorZip.ts(111,6): error TS2339: Property 'd' does not exist on type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator | undefined; readonly c?: Iterable | undefined; }, never, {}>'. -iteratorZip.ts(112,7): error TS2322: Type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator | undefined; readonly c?: Iterable | undefined; }, never, {}>[]' is not assignable to type '{ a: number; c: boolean; }[]'. - Type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator | undefined; readonly c?: Iterable | undefined; }, never, {}>' is not assignable to type '{ a: number; c: boolean; }'. +iteratorZip.ts(93,8): error TS2339: Property 'b' does not exist on type '{ a: number; } & {}'. +iteratorZip.ts(109,8): error TS2339: Property 'd' does not exist on type '{ a: number; } & { b?: string | undefined; c?: IteratorZipValue | undefined, "c", never, {}> | undefined; }'. +iteratorZip.ts(110,7): error TS2322: Type '({ a: number; } & { b?: string | undefined; c?: IteratorZipValue | undefined, "c", never, {}> | undefined; })[]' is not assignable to type '{ a: number; c: boolean; }[]'. + Type '{ a: number; } & { b?: string | undefined; c?: IteratorZipValue | undefined, "c", never, {}> | undefined; }' is not assignable to type '{ a: number; c: boolean; }'. Types of property 'c' are incompatible. Type 'boolean | undefined' is not assignable to type 'boolean'. Type 'undefined' is not assignable to type 'boolean'. -iteratorZip.ts(132,14): error TS2769: No overload matches this call. +iteratorZip.ts(130,14): error TS2769: No overload matches this call. The last overload gave the following error. Argument of type 'undefined[]' is not assignable to parameter of type 'Iterable> & object'. Type 'undefined[]' is not assignable to type 'Iterable>'. @@ -69,155 +69,159 @@ iteratorZip.ts(132,14): error TS2769: No overload matches this call. Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>'. Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>'. Type 'undefined' is not assignable to type 'IteratorInput'. -iteratorZip.ts(150,7): error TS2322: Type '[number, ...(number | undefined)[]][]' is not assignable to type 'number[][]'. - Type '[number, ...(number | undefined)[]]' is not assignable to type 'number[]'. - Type 'number | undefined' is not assignable to type 'number'. +iteratorZip.ts(146,7): error TS2322: Type '[number, ...IteratorZipValue, number, undefined, [number]>[]][]' is not assignable to type 'number[][]'. + Type '[number, ...IteratorZipValue, number, undefined, [number]>[]]' is not assignable to type 'number[]'. + Type 'IteratorZipValue, number, undefined, [number]>' is not assignable to type 'number'. Type 'undefined' is not assignable to type 'number'. -iteratorZip.ts(155,7): error TS2322: Type 'IteratorZipResult<{ [x: string]: Iterable; } & {}, undefined, {}>[]' is not assignable to type 'Record[]'. - Type 'IteratorZipResult<{ [x: string]: Iterable; } & {}, undefined, {}>' is not assignable to type 'Record'. +iteratorZip.ts(151,7): error TS2322: Type '({ [x: string]: IteratorZipValue, string, undefined, {}>; } & {})[]' is not assignable to type 'Record[]'. + Type '{ [x: string]: IteratorZipValue, string, undefined, {}>; } & {}' is not assignable to type 'Record'. 'string' index signatures are incompatible. - Type 'number | undefined' is not assignable to type 'number'. + Type 'IteratorZipValue, string, undefined, {}>' is not assignable to type 'number'. Type 'undefined' is not assignable to type 'number'. -iteratorZip.ts(160,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record>[]' is not assignable to type '{ a: number; b: number; }[]'. - Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record>' is not assignable to type '{ a: number; b: number; }'. +iteratorZip.ts(156,7): error TS2322: Type '({ a: IteratorZipValue>; b: IteratorZipValue>; } & {})[]' is not assignable to type '{ a: number; b: number; }[]'. + Type '{ a: IteratorZipValue>; b: IteratorZipValue>; } & {}' is not assignable to type '{ a: number; b: number; }'. Types of property 'a' are incompatible. - Type 'number | undefined' is not assignable to type 'number'. + Type 'IteratorZipValue>' is not assignable to type 'number'. Type 'undefined' is not assignable to type 'number'. -iteratorZip.ts(169,7): error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. - Type '[number, string | undefined]' is not assignable to type '[number, string]'. +iteratorZip.ts(165,7): error TS2322: Type '[number, IteratorZipValue][]' is not assignable to type '[number, string][]'. + Type '[number, IteratorZipValue]' is not assignable to type '[number, string]'. Type at position 1 in source is not compatible with type at position 1 in target. - Type 'string | undefined' is not assignable to type 'string'. + Type 'IteratorZipValue' is not assignable to type 'string'. Type 'undefined' is not assignable to type 'string'. -iteratorZip.ts(172,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; }>[]' is not assignable to type '{ a: number; b: string; }[]'. - Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; b: string; }'. +iteratorZip.ts(168,7): error TS2322: Type '({ a: number; b: IteratorZipValue; } & {})[]' is not assignable to type '{ a: number; b: string; }[]'. + Type '{ a: number; b: IteratorZipValue; } & {}' is not assignable to type '{ a: number; b: string; }'. Types of property 'b' are incompatible. - Type 'string | undefined' is not assignable to type 'string'. + Type 'IteratorZipValue' is not assignable to type 'string'. Type 'undefined' is not assignable to type 'string'. -iteratorZip.ts(178,7): error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. - Type '[number, string | undefined]' is not assignable to type '[number, string]'. +iteratorZip.ts(174,7): error TS2322: Type '[number, IteratorZipValue][]' is not assignable to type '[number, string][]'. + Type '[number, IteratorZipValue]' is not assignable to type '[number, string]'. Type at position 1 in source is not compatible with type at position 1 in target. - Type 'string | undefined' is not assignable to type 'string'. + Type 'IteratorZipValue' is not assignable to type 'string'. Type 'undefined' is not assignable to type 'string'. -iteratorZip.ts(182,7): error TS2322: Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>[]' is not assignable to type 'number[][]'. +iteratorZip.ts(178,7): error TS2322: Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>[]' is not assignable to type 'number[][]'. Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>' is not assignable to type 'number[]'. - Type '[number, number | undefined]' is not assignable to type 'number[]'. - Type 'number | undefined' is not assignable to type 'number'. + Type '[number, IteratorZipValue, "1", undefined, [number]>]' is not assignable to type 'number[]'. + Type 'IteratorZipValue, "1", undefined, [number]>' is not assignable to type 'number'. Type 'undefined' is not assignable to type 'number'. -iteratorZip.ts(185,7): error TS2322: Type '(IteratorZipResult<{ a: Iterable; } & {}, undefined, { a: number; }> | IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>)[]' is not assignable to type '({ a: number; } | { b: string; })[]'. - Type 'IteratorZipResult<{ a: Iterable; } & {}, undefined, { a: number; }> | IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; } | { b: string; }'. - Type 'IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; } | { b: string; }'. - Type 'IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ b: string; }'. +iteratorZip.ts(181,7): error TS2322: Type '(({ a: number; } & {}) | ({ b: IteratorZipValue, "b", undefined, { a: number; }>; } & {}))[]' is not assignable to type '({ a: number; } | { b: string; })[]'. + Type '({ a: number; } & {}) | ({ b: IteratorZipValue, "b", undefined, { a: number; }>; } & {})' is not assignable to type '{ a: number; } | { b: string; }'. + Type '{ b: IteratorZipValue, "b", undefined, { a: number; }>; } & {}' is not assignable to type '{ a: number; } | { b: string; }'. + Type '{ b: IteratorZipValue, "b", undefined, { a: number; }>; } & {}' is not assignable to type '{ b: string; }'. Types of property 'b' are incompatible. - Type 'string | undefined' is not assignable to type 'string'. + Type 'IteratorZipValue, "b", undefined, { a: number; }>' is not assignable to type 'string'. Type 'undefined' is not assignable to type 'string'. -iteratorZip.ts(189,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; } | { b: string; }>[]' is not assignable to type '{ a: number; b: string; }[]'. - Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; } | { b: string; }>' is not assignable to type '{ a: number; b: string; }'. +iteratorZip.ts(185,7): error TS2322: Type '({ a: IteratorZipValue; b: IteratorZipValue; } & {})[]' is not assignable to type '{ a: number; b: string; }[]'. + Type '{ a: IteratorZipValue; b: IteratorZipValue; } & {}' is not assignable to type '{ a: number; b: string; }'. Types of property 'a' are incompatible. - Type 'number | undefined' is not assignable to type 'number'. + Type 'IteratorZipValue' is not assignable to type 'number'. Type 'undefined' is not assignable to type 'number'. -iteratorZip.ts(192,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, { a: undefined; b: number; }>[]' is not assignable to type '{ a: number; b: number; }[]'. - Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, { a: undefined; b: number; }>' is not assignable to type '{ a: number; b: number; }'. +iteratorZip.ts(188,7): error TS2322: Type '({ a: IteratorZipValue; b: number; } & {})[]' is not assignable to type '{ a: number; b: number; }[]'. + Type '{ a: IteratorZipValue; b: number; } & {}' is not assignable to type '{ a: number; b: number; }'. Types of property 'a' are incompatible. - Type 'number | undefined' is not assignable to type 'number'. + Type 'IteratorZipValue' is not assignable to type 'number'. Type 'undefined' is not assignable to type 'number'. -iteratorZip.ts(196,7): error TS2322: Type 'IteratorZipResult<{ [x: `a${string}`]: Iterable; } & {}, undefined, {}>[]' is not assignable to type '{ [x: `a${string}`]: number; }[]'. - Type 'IteratorZipResult<{ [x: `a${string}`]: Iterable; } & {}, undefined, {}>' is not assignable to type '{ [x: `a${string}`]: number; }'. +iteratorZip.ts(192,7): error TS2322: Type '({ [x: `a${string}`]: IteratorZipValue, `a${string}`, undefined, {}>; } & {})[]' is not assignable to type '{ [x: `a${string}`]: number; }[]'. + Type '{ [x: `a${string}`]: IteratorZipValue, `a${string}`, undefined, {}>; } & {}' is not assignable to type '{ [x: `a${string}`]: number; }'. '`a${string}`' index signatures are incompatible. - Type 'number | undefined' is not assignable to type 'number'. + Type 'IteratorZipValue, `a${string}`, undefined, {}>' is not assignable to type 'number'. Type 'undefined' is not assignable to type 'number'. -iteratorZip.ts(204,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record & { a: number; }>[]' is not assignable to type '{ a: number; b: number; }[]'. - Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record & { a: number; }>' is not assignable to type '{ a: number; b: number; }'. +iteratorZip.ts(200,7): error TS2322: Type '({ a: number; b: IteratorZipValue & { a: number; }>; } & {})[]' is not assignable to type '{ a: number; b: number; }[]'. + Type '{ a: number; b: IteratorZipValue & { a: number; }>; } & {}' is not assignable to type '{ a: number; b: number; }'. Types of property 'b' are incompatible. - Type 'number | undefined' is not assignable to type 'number'. + Type 'IteratorZipValue & { a: number; }>' is not assignable to type 'number'. Type 'undefined' is not assignable to type 'number'. -iteratorZip.ts(209,7): error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. - Type '[number, string | undefined]' is not assignable to type '[number, string]'. +iteratorZip.ts(205,7): error TS2322: Type '[number, IteratorZipValue][]' is not assignable to type '[number, string][]'. + Type '[number, IteratorZipValue]' is not assignable to type '[number, string]'. Type at position 1 in source is not compatible with type at position 1 in target. - Type 'string | undefined' is not assignable to type 'string'. + Type 'IteratorZipValue' is not assignable to type 'string'. Type 'undefined' is not assignable to type 'string'. -iteratorZip.ts(248,7): error TS2322: Type 'unknown' is not assignable to type 'string'. -iteratorZip.ts(249,7): error TS2322: Type 'unknown' is not assignable to type 'string'. -iteratorZip.ts(258,19): error TS2769: No overload matches this call. +iteratorZip.ts(238,7): error TS2322: Type 'unknown' is not assignable to type 'string'. +iteratorZip.ts(239,7): error TS2322: Type 'unknown' is not assignable to type 'string'. +iteratorZip.ts(255,7): error TS2322: Type 'Record[]' is not assignable to type 'never[]'. + Type 'Record' is not assignable to type 'never'. +iteratorZip.ts(260,7): error TS2322: Type 'Record[]' is not assignable to type 'never[]'. + Type 'Record' is not assignable to type 'never'. +iteratorZip.ts(262,19): error TS2769: No overload matches this call. The last overload gave the following error. Argument of type '0' is not assignable to parameter of type 'never'. -iteratorZip.ts(259,19): error TS2769: No overload matches this call. +iteratorZip.ts(263,19): error TS2769: No overload matches this call. The last overload gave the following error. Argument of type 'null' is not assignable to parameter of type 'never'. -iteratorZip.ts(260,31): error TS2769: No overload matches this call. +iteratorZip.ts(264,27): error TS2769: No overload matches this call. The last overload gave the following error. Type '"invalid"' is not assignable to type '"longest" | "shortest" | "strict" | undefined'. -iteratorZip.ts(261,49): error TS2769: No overload matches this call. +iteratorZip.ts(265,45): error TS2769: No overload matches this call. The last overload gave the following error. Object literal may only specify known properties, and 'padding' does not exist in type 'IteratorZipShortestOptions'. -iteratorZip.ts(262,48): error TS2769: No overload matches this call. +iteratorZip.ts(266,44): error TS2769: No overload matches this call. The last overload gave the following error. Type 'number' is not assignable to type 'object'. -iteratorZip.ts(263,19): error TS2769: No overload matches this call. +iteratorZip.ts(267,19): error TS2769: No overload matches this call. The last overload gave the following error. - Argument of type '{ values: number[]; }' is not assignable to parameter of type 'never'. + Argument of type '{ a: number[]; }' is not assignable to parameter of type 'never'. -==== iteratorZip.ts (36 errors) ==== - declare const key: unique symbol; +==== iteratorZip.ts (38 errors) ==== + declare const a1: unique symbol; - const tuples: [number, string][] = Iterator.zip([ + const a2: [number, string][] = Iterator.zip([ [1, 2], new Set(["a", "b"]), ] as const).toArray(); - tuples[0][0] = 2; + a2[0][0] = 2; - const shortestTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray(); - const strictTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray(); - const longestTuplesWithPadding: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray(); - const longestTuplesWithoutPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray(); - const longestTuplesWithPartialPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray(); + const a3: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray(); + const a4: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray(); + const a5: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray(); + const a6: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray(); + const a7: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray(); - declare const maybeLongestOptions: { mode: "shortest"; } | { mode: "longest"; }; - const maybeLongestTuples: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray(); + declare const a8: { mode: "shortest"; } | { mode: "longest"; }; + const a9: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, a8).toArray(); - const empty: never[] = Iterator.zip([]).toArray(); - const emptyLongest: never[] = Iterator.zip([], { mode: "longest" }).toArray(); + const a10: never[] = Iterator.zip([]).toArray(); + const a11: never[] = Iterator.zip([], { mode: "longest" }).toArray(); - declare const iterables: Iterable>; - const arrays: number[][] = Iterator.zip(iterables).toArray(); - const longestArrays: (number | undefined)[][] = Iterator.zip(iterables, { mode: "longest" }).toArray(); - const maybeLongestArrays: (number | undefined)[][] = Iterator.zip(iterables, maybeLongestOptions).toArray(); + declare const a12: Iterable>; + const a13: number[][] = Iterator.zip(a12).toArray(); + const a14: (number | undefined)[][] = Iterator.zip(a12, { mode: "longest" }).toArray(); + const a15: (number | undefined)[][] = Iterator.zip(a12, a8).toArray(); - declare const iterableArray: Iterable[]; - const longestArrayWithPadding: (number | undefined)[][] = Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray(); + declare const a16: Iterable[]; + const a17: (number | undefined)[][] = Iterator.zip(a16, { mode: "longest", padding: [] }).toArray(); - const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ + const a18: { a: number; b: string; [a1]: boolean; }[] = Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), - [key]: [true, false], + [a1]: [true, false], } as const).toArray(); - objects[0].a = 2; + a18[0].a = 2; - const longestObjectsWithPadding: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { + const a19: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" }, }).toArray(); - const longestObjectsWithoutPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { + const a20: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", }).toArray(); - const longestObjectsWithPartialPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { + const a21: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" }, }).toArray(); - const maybeLongestObjects: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray(); + const a22: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, a8).toArray(); - interface Inputs { + interface I1 { a: Iterable; b: Iterator; } - declare const inputs: Inputs; - const rows: { a: number; b: string; }[] = Iterator.zipKeyed(inputs).toArray(); + declare const a23: I1; + const a24: { a: number; b: string; }[] = Iterator.zipKeyed(a23).toArray(); Iterator.zip([[1]], { mode: "invalid" }); ~~~~ @@ -256,13 +260,11 @@ iteratorZip.ts(263,19): error TS2769: No overload matches this call. Iterator.zipKeyed({ a: 0 }); - const emptyKeyed: never[] = Iterator.zipKeyed({}).toArray(); - const emptyKeyedLongest: never[] = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); + const a25: Record[] = Iterator.zipKeyed({}).toArray(); + const a26: Record[] = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); - declare const unionInputs: { a: Iterable; } | { b: Iterator; }; - const unionRows: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(unionInputs).toArray(); - - // Inputs + declare const a27: { a: Iterable; } | { b: Iterator; }; + const a28: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(a27).toArray(); Iterator.zip("ab"); ~~~~ @@ -323,56 +325,56 @@ iteratorZip.ts(263,19): error TS2769: No overload matches this call. !!! error TS2769: Argument of type '{}' is not assignable to parameter of type 'never'. !!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. - const a: [string][] = Iterator.zip([new String("ab")]).toArray(); - const b: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); - const c: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); + const a29: [string][] = Iterator.zip([new String("ab")]).toArray(); + const a30: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); + const a31: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); - const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); - const e: { a: number; }[] = d; - d[0].b; - ~ -!!! error TS2339: Property 'b' does not exist on type 'IteratorZipResult<{ a: number[]; } & {}, never, {}>'. - const f: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); - const g: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); + const a32 = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); + const a33: { a: number; }[] = a32; + a32[0].b; + ~ +!!! error TS2339: Property 'b' does not exist on type '{ a: number; } & {}'. + const a34: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); + const a35: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); - interface I { + interface I2 { readonly a: Iterable; readonly b?: Iterator; readonly c: Iterable | undefined; readonly d?: undefined; } - declare const h: I; - const i = Iterator.zipKeyed(h).toArray(); - const j: { a: number; b?: string; c?: boolean; }[] = i; - i[0].a = 2; - i[0].b = "a"; - i[0].c = true; - i[0].d; - ~ -!!! error TS2339: Property 'd' does not exist on type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator | undefined; readonly c?: Iterable | undefined; }, never, {}>'. - const k: { a: number; c: boolean; }[] = i; - ~ -!!! error TS2322: Type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator | undefined; readonly c?: Iterable | undefined; }, never, {}>[]' is not assignable to type '{ a: number; c: boolean; }[]'. -!!! error TS2322: Type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator | undefined; readonly c?: Iterable | undefined; }, never, {}>' is not assignable to type '{ a: number; c: boolean; }'. + declare const a36: I2; + const a37 = Iterator.zipKeyed(a36).toArray(); + const a38: { a: number; b?: string; c?: boolean; }[] = a37; + a37[0].a = 2; + a37[0].b = "a"; + a37[0].c = true; + a37[0].d; + ~ +!!! error TS2339: Property 'd' does not exist on type '{ a: number; } & { b?: string | undefined; c?: IteratorZipValue | undefined, "c", never, {}> | undefined; }'. + const a39: { a: number; c: boolean; }[] = a37; + ~~~ +!!! error TS2322: Type '({ a: number; } & { b?: string | undefined; c?: IteratorZipValue | undefined, "c", never, {}> | undefined; })[]' is not assignable to type '{ a: number; c: boolean; }[]'. +!!! error TS2322: Type '{ a: number; } & { b?: string | undefined; c?: IteratorZipValue | undefined, "c", never, {}> | undefined; }' is not assignable to type '{ a: number; c: boolean; }'. !!! error TS2322: Types of property 'c' are incompatible. !!! error TS2322: Type 'boolean | undefined' is not assignable to type 'boolean'. !!! error TS2322: Type 'undefined' is not assignable to type 'boolean'. - const l: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); - - declare const m: { a: Iterable; } | { b: Iterator; }; - const n: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(m).toArray(); - declare const o: { a: Iterable; } | { b: number; }; - Iterator.zipKeyed(o); - Iterator.zipKeyed(o, { mode: "longest" }); - Iterator.zipKeyed(o, { mode: "longest", padding: {} }); - declare const p: { a?: Iterable; } | { b: string; }; - Iterator.zipKeyed(p); - declare const q: { a: Iterable; } | { b: undefined; }; - const r: { a: number; }[] = Iterator.zipKeyed(q).toArray(); - - declare const s: unique symbol; - declare const t: { a: Iterable; [s]?: Iterable; }; - const u: { a: number; [s]?: string; }[] = Iterator.zipKeyed(t).toArray(); + const a40: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(a36, { mode: "longest" }).toArray(); + + declare const a41: { a: Iterable; } | { b: Iterator; }; + const a42: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(a41).toArray(); + declare const a43: { a: Iterable; } | { b: number; }; + Iterator.zipKeyed(a43); + Iterator.zipKeyed(a43, { mode: "longest" }); + Iterator.zipKeyed(a43, { mode: "longest", padding: {} }); + declare const a44: { a?: Iterable; } | { b: string; }; + Iterator.zipKeyed(a44); + declare const a45: { a: Iterable; } | { b: undefined; }; + const a46: { a: number; }[] = Iterator.zipKeyed(a45).toArray(); + + declare const a47: unique symbol; + declare const a48: { a: Iterable; [a47]?: Iterable; }; + const a49: { a: number; [a47]?: string; }[] = Iterator.zipKeyed(a48).toArray(); Iterator.zipKeyed({ a: [1], b: null }); Iterator.zipKeyed({ a: [1], b: false }); @@ -389,10 +391,10 @@ iteratorZip.ts(263,19): error TS2769: No overload matches this call. !!! error TS2769: Type 'undefined' is not assignable to type 'IteratorInput'. !!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. - declare const v: { a?: undefined; }; - const w: never[] = Iterator.zipKeyed(v).toArray(); - const x: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); - const y: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); + declare const a50: { a?: undefined; }; + const a51: never[] = Iterator.zipKeyed(a50).toArray(); + const a52: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); + const a53: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); function f1(a: Iterable) { const b: { a: T; }[] = Iterator.zipKeyed({ a }).toArray(); @@ -400,201 +402,213 @@ iteratorZip.ts(263,19): error TS2769: No overload matches this call. return { b, c }; } - // Padding - - const paddingA: [Iterable, ...Iterable[]] = [[1, 2], [3]]; - const paddingB = Iterator.zip(paddingA, { mode: "longest", padding: [0] }).toArray(); - const paddingC: (number | undefined)[][] = paddingB; - const paddingD: number[][] = paddingB; - ~~~~~~~~ -!!! error TS2322: Type '[number, ...(number | undefined)[]][]' is not assignable to type 'number[][]'. -!!! error TS2322: Type '[number, ...(number | undefined)[]]' is not assignable to type 'number[]'. -!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. + const a54: [Iterable, ...Iterable[]] = [[1, 2], [3]]; + const a55 = Iterator.zip(a54, { mode: "longest", padding: [0] }).toArray(); + const a56: (number | undefined)[][] = a55; + const a57: number[][] = a55; + ~~~ +!!! error TS2322: Type '[number, ...IteratorZipValue, number, undefined, [number]>[]][]' is not assignable to type 'number[][]'. +!!! error TS2322: Type '[number, ...IteratorZipValue, number, undefined, [number]>[]]' is not assignable to type 'number[]'. +!!! error TS2322: Type 'IteratorZipValue, number, undefined, [number]>' is not assignable to type 'number'. !!! error TS2322: Type 'undefined' is not assignable to type 'number'. - const paddingE: Record> = { a: [1], b: [2, 3] }; - const paddingF = Iterator.zipKeyed(paddingE, { mode: "longest", padding: {} }).toArray(); - const paddingG: Record[] = paddingF; - const paddingH: Record[] = paddingF; - ~~~~~~~~ -!!! error TS2322: Type 'IteratorZipResult<{ [x: string]: Iterable; } & {}, undefined, {}>[]' is not assignable to type 'Record[]'. -!!! error TS2322: Type 'IteratorZipResult<{ [x: string]: Iterable; } & {}, undefined, {}>' is not assignable to type 'Record'. + const a58: Record> = { a: [1], b: [2, 3] }; + const a59 = Iterator.zipKeyed(a58, { mode: "longest", padding: {} }).toArray(); + const a60: Record[] = a59; + const a61: Record[] = a59; + ~~~ +!!! error TS2322: Type '({ [x: string]: IteratorZipValue, string, undefined, {}>; } & {})[]' is not assignable to type 'Record[]'. +!!! error TS2322: Type '{ [x: string]: IteratorZipValue, string, undefined, {}>; } & {}' is not assignable to type 'Record'. !!! error TS2322: 'string' index signatures are incompatible. -!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'IteratorZipValue, string, undefined, {}>' is not assignable to type 'number'. !!! error TS2322: Type 'undefined' is not assignable to type 'number'. - declare const paddingI: Record; - const paddingJ = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: paddingI }).toArray(); - const paddingK: { a: number | undefined; b: number | undefined; }[] = paddingJ; - const paddingL: { a: number; b: number; }[] = paddingJ; - ~~~~~~~~ -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record>[]' is not assignable to type '{ a: number; b: number; }[]'. -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record>' is not assignable to type '{ a: number; b: number; }'. + declare const a62: Record; + const a63 = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a62 }).toArray(); + const a64: { a: number | undefined; b: number | undefined; }[] = a63; + const a65: { a: number; b: number; }[] = a63; + ~~~ +!!! error TS2322: Type '({ a: IteratorZipValue>; b: IteratorZipValue>; } & {})[]' is not assignable to type '{ a: number; b: number; }[]'. +!!! error TS2322: Type '{ a: IteratorZipValue>; b: IteratorZipValue>; } & {}' is not assignable to type '{ a: number; b: number; }'. !!! error TS2322: Types of property 'a' are incompatible. -!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'IteratorZipValue>' is not assignable to type 'number'. !!! error TS2322: Type 'undefined' is not assignable to type 'number'. - const paddingM = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); - const paddingN: [number, string][] = paddingM; - const paddingO = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); - const paddingP: { a: number; b: string; }[] = paddingO; - - const paddingQ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); - const paddingR: [number | undefined, string | undefined][] = paddingQ; - const paddingS: [number, string][] = paddingQ; - ~~~~~~~~ -!!! error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. -!!! error TS2322: Type '[number, string | undefined]' is not assignable to type '[number, string]'. + const a66 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); + const a67: [number, string][] = a66; + const a68 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); + const a69: { a: number; b: string; }[] = a68; + + const a70 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); + const a71: [number | undefined, string | undefined][] = a70; + const a72: [number, string][] = a70; + ~~~ +!!! error TS2322: Type '[number, IteratorZipValue][]' is not assignable to type '[number, string][]'. +!!! error TS2322: Type '[number, IteratorZipValue]' is not assignable to type '[number, string]'. !!! error TS2322: Type at position 1 in source is not compatible with type at position 1 in target. -!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. +!!! error TS2322: Type 'IteratorZipValue' is not assignable to type 'string'. !!! error TS2322: Type 'undefined' is not assignable to type 'string'. - const paddingT = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); - const paddingU: { a: number | undefined; b: string | undefined; }[] = paddingT; - const paddingV: { a: number; b: string; }[] = paddingT; - ~~~~~~~~ -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; }>[]' is not assignable to type '{ a: number; b: string; }[]'. -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; b: string; }'. + const a73 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); + const a74: { a: number | undefined; b: string | undefined; }[] = a73; + const a75: { a: number; b: string; }[] = a73; + ~~~ +!!! error TS2322: Type '({ a: number; b: IteratorZipValue; } & {})[]' is not assignable to type '{ a: number; b: string; }[]'. +!!! error TS2322: Type '{ a: number; b: IteratorZipValue; } & {}' is not assignable to type '{ a: number; b: string; }'. !!! error TS2322: Types of property 'b' are incompatible. -!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. +!!! error TS2322: Type 'IteratorZipValue' is not assignable to type 'string'. !!! error TS2322: Type 'undefined' is not assignable to type 'string'. - declare const paddingW: readonly [number, string]; - const paddingX: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingW }).toArray(); - declare const paddingY: [number, string?]; - const paddingZ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY }).toArray(); - const paddingA1: [number, string][] = paddingZ; - ~~~~~~~~~ -!!! error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. -!!! error TS2322: Type '[number, string | undefined]' is not assignable to type '[number, string]'. + declare const a76: readonly [number, string]; + const a77: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a76 }).toArray(); + declare const a78: [number, string?]; + const a79 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a78 }).toArray(); + const a80: [number, string][] = a79; + ~~~ +!!! error TS2322: Type '[number, IteratorZipValue][]' is not assignable to type '[number, string][]'. +!!! error TS2322: Type '[number, IteratorZipValue]' is not assignable to type '[number, string]'. !!! error TS2322: Type at position 1 in source is not compatible with type at position 1 in target. -!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. +!!! error TS2322: Type 'IteratorZipValue' is not assignable to type 'string'. !!! error TS2322: Type 'undefined' is not assignable to type 'string'. - declare const paddingB1: [Iterable] | [Iterable, Iterable]; - const paddingC1 = Iterator.zip(paddingB1, { mode: "longest", padding: [0] }).toArray(); - const paddingD1: number[][] = paddingC1; - ~~~~~~~~~ + declare const a81: [Iterable] | [Iterable, Iterable]; + const a82 = Iterator.zip(a81, { mode: "longest", padding: [0] }).toArray(); + const a83: number[][] = a82; + ~~~ !!! error TS2322: Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>[]' is not assignable to type 'number[][]'. !!! error TS2322: Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>' is not assignable to type 'number[]'. -!!! error TS2322: Type '[number, number | undefined]' is not assignable to type 'number[]'. -!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type '[number, IteratorZipValue, "1", undefined, [number]>]' is not assignable to type 'number[]'. +!!! error TS2322: Type 'IteratorZipValue, "1", undefined, [number]>' is not assignable to type 'number'. !!! error TS2322: Type 'undefined' is not assignable to type 'number'. - declare const paddingE1: { a: Iterable; } | { b: Iterable; }; - const paddingF1 = Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: 0 } }).toArray(); - const paddingG1: ({ a: number; } | { b: string; })[] = paddingF1; - ~~~~~~~~~ -!!! error TS2322: Type '(IteratorZipResult<{ a: Iterable; } & {}, undefined, { a: number; }> | IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>)[]' is not assignable to type '({ a: number; } | { b: string; })[]'. -!!! error TS2322: Type 'IteratorZipResult<{ a: Iterable; } & {}, undefined, { a: number; }> | IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; } | { b: string; }'. -!!! error TS2322: Type 'IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; } | { b: string; }'. -!!! error TS2322: Type 'IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ b: string; }'. + declare const a84: { a: Iterable; } | { b: Iterable; }; + const a85 = Iterator.zipKeyed(a84, { mode: "longest", padding: { a: 0 } }).toArray(); + const a86: ({ a: number; } | { b: string; })[] = a85; + ~~~ +!!! error TS2322: Type '(({ a: number; } & {}) | ({ b: IteratorZipValue, "b", undefined, { a: number; }>; } & {}))[]' is not assignable to type '({ a: number; } | { b: string; })[]'. +!!! error TS2322: Type '({ a: number; } & {}) | ({ b: IteratorZipValue, "b", undefined, { a: number; }>; } & {})' is not assignable to type '{ a: number; } | { b: string; }'. +!!! error TS2322: Type '{ b: IteratorZipValue, "b", undefined, { a: number; }>; } & {}' is not assignable to type '{ a: number; } | { b: string; }'. +!!! error TS2322: Type '{ b: IteratorZipValue, "b", undefined, { a: number; }>; } & {}' is not assignable to type '{ b: string; }'. !!! error TS2322: Types of property 'b' are incompatible. -!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. +!!! error TS2322: Type 'IteratorZipValue, "b", undefined, { a: number; }>' is not assignable to type 'string'. !!! error TS2322: Type 'undefined' is not assignable to type 'string'. - declare const paddingH1: { a: number; } | { b: string; }; - const paddingI1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: paddingH1 }).toArray(); - const paddingJ1: { a: number; b: string; }[] = paddingI1; - ~~~~~~~~~ -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; } | { b: string; }>[]' is not assignable to type '{ a: number; b: string; }[]'. -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; } | { b: string; }>' is not assignable to type '{ a: number; b: string; }'. + declare const a87: { a: number; } | { b: string; }; + const a88 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: a87 }).toArray(); + const a89: { a: number; b: string; }[] = a88; + ~~~ +!!! error TS2322: Type '({ a: IteratorZipValue; b: IteratorZipValue; } & {})[]' is not assignable to type '{ a: number; b: string; }[]'. +!!! error TS2322: Type '{ a: IteratorZipValue; b: IteratorZipValue; } & {}' is not assignable to type '{ a: number; b: string; }'. !!! error TS2322: Types of property 'a' are incompatible. -!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'IteratorZipValue' is not assignable to type 'number'. !!! error TS2322: Type 'undefined' is not assignable to type 'number'. - const paddingK1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); - const paddingL1: { a: number; b: number; }[] = paddingK1; - ~~~~~~~~~ -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, { a: undefined; b: number; }>[]' is not assignable to type '{ a: number; b: number; }[]'. -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, { a: undefined; b: number; }>' is not assignable to type '{ a: number; b: number; }'. + const a90 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); + const a91: { a: number; b: number; }[] = a90; + ~~~ +!!! error TS2322: Type '({ a: IteratorZipValue; b: number; } & {})[]' is not assignable to type '{ a: number; b: number; }[]'. +!!! error TS2322: Type '{ a: IteratorZipValue; b: number; } & {}' is not assignable to type '{ a: number; b: number; }'. !!! error TS2322: Types of property 'a' are incompatible. -!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'IteratorZipValue' is not assignable to type 'number'. !!! error TS2322: Type 'undefined' is not assignable to type 'number'. - declare const paddingM1: { [K in `a${string}`]: Iterable; }; - const paddingN1 = Iterator.zipKeyed(paddingM1, { mode: "longest", padding: {} }).toArray(); - const paddingO1: { [K in `a${string}`]: number; }[] = paddingN1; - ~~~~~~~~~ -!!! error TS2322: Type 'IteratorZipResult<{ [x: `a${string}`]: Iterable; } & {}, undefined, {}>[]' is not assignable to type '{ [x: `a${string}`]: number; }[]'. -!!! error TS2322: Type 'IteratorZipResult<{ [x: `a${string}`]: Iterable; } & {}, undefined, {}>' is not assignable to type '{ [x: `a${string}`]: number; }'. + declare const a92: { [K in `a${string}`]: Iterable; }; + const a93 = Iterator.zipKeyed(a92, { mode: "longest", padding: {} }).toArray(); + const a94: { [K in `a${string}`]: number; }[] = a93; + ~~~ +!!! error TS2322: Type '({ [x: `a${string}`]: IteratorZipValue, `a${string}`, undefined, {}>; } & {})[]' is not assignable to type '{ [x: `a${string}`]: number; }[]'. +!!! error TS2322: Type '{ [x: `a${string}`]: IteratorZipValue, `a${string}`, undefined, {}>; } & {}' is not assignable to type '{ [x: `a${string}`]: number; }'. !!! error TS2322: '`a${string}`' index signatures are incompatible. -!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'IteratorZipValue, `a${string}`, undefined, {}>' is not assignable to type 'number'. !!! error TS2322: Type 'undefined' is not assignable to type 'number'. - declare const paddingP1: unique symbol; - const paddingQ1: { [paddingP1]: number; }[] = Iterator.zipKeyed({ [paddingP1]: [1] }, { mode: "longest", padding: { [paddingP1]: 0 } }).toArray(); + declare const a95: unique symbol; + const a96: { [a95]: number; }[] = Iterator.zipKeyed({ [a95]: [1] }, { mode: "longest", padding: { [a95]: 0 } }).toArray(); - declare const paddingR1: Record & { a: number; }; - const paddingS1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: paddingR1 }).toArray(); - const paddingT1: { a: number; b: number | undefined; }[] = paddingS1; - const paddingU1: { a: number; b: number; }[] = paddingS1; - ~~~~~~~~~ -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record & { a: number; }>[]' is not assignable to type '{ a: number; b: number; }[]'. -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record & { a: number; }>' is not assignable to type '{ a: number; b: number; }'. + declare const a97: Record & { a: number; }; + const a98 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: a97 }).toArray(); + const a99: { a: number; b: number | undefined; }[] = a98; + const a100: { a: number; b: number; }[] = a98; + ~~~~ +!!! error TS2322: Type '({ a: number; b: IteratorZipValue & { a: number; }>; } & {})[]' is not assignable to type '{ a: number; b: number; }[]'. +!!! error TS2322: Type '{ a: number; b: IteratorZipValue & { a: number; }>; } & {}' is not assignable to type '{ a: number; b: number; }'. !!! error TS2322: Types of property 'b' are incompatible. -!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'IteratorZipValue & { a: number; }>' is not assignable to type 'number'. !!! error TS2322: Type 'undefined' is not assignable to type 'number'. - declare const paddingV1: [number] | [number, string]; - const paddingW1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingV1 }).toArray(); - const paddingX1: [number, string | undefined][] = paddingW1; - const paddingY1: [number, string][] = paddingW1; - ~~~~~~~~~ -!!! error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. -!!! error TS2322: Type '[number, string | undefined]' is not assignable to type '[number, string]'. + declare const a101: [number] | [number, string]; + const a102 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a101 }).toArray(); + const a103: [number, string | undefined][] = a102; + const a104: [number, string][] = a102; + ~~~~ +!!! error TS2322: Type '[number, IteratorZipValue][]' is not assignable to type '[number, string][]'. +!!! error TS2322: Type '[number, IteratorZipValue]' is not assignable to type '[number, string]'. !!! error TS2322: Type at position 1 in source is not compatible with type at position 1 in target. -!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. +!!! error TS2322: Type 'IteratorZipValue' is not assignable to type 'string'. !!! error TS2322: Type 'undefined' is not assignable to type 'string'. - const paddingZ1: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); - const paddingA2: { a: number | undefined; b: number; }[] = paddingK1; - - // Own properties + const a105: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); + const a106: { a: number | undefined; b: number; }[] = a90; - class InputsWithPrototypeMembers { - values = [1, 2]; + class C1 { + a = [1, 2]; - get label() { + get b() { return "inputs"; } - describe() { - return this.label; + f() { + return this.b; } } - const instance = new InputsWithPrototypeMembers(); - const inherited = Iterator.zipKeyed(instance).toArray(); - const inheritedStrict = Iterator.zipKeyed(instance, { mode: "strict" }).toArray(); - const inheritedLongest = Iterator.zipKeyed(instance, { mode: "longest" }).toArray(); - const inheritedPadded = Iterator.zipKeyed(instance, { mode: "longest", padding: { values: 0 } }).toArray(); + const a107 = new C1(); + const a108 = Iterator.zipKeyed(a107).toArray(); + const a109 = Iterator.zipKeyed(a107, { mode: "strict" }).toArray(); + const a110 = Iterator.zipKeyed(a107, { mode: "longest" }).toArray(); + const a111 = Iterator.zipKeyed(a107, { mode: "longest", padding: { a: 0 } }).toArray(); - const hiddenInputs = { values: [1, 2], label: "inputs" }; - Object.defineProperty(hiddenInputs, "label", { enumerable: false }); - const nonEnumerable = Iterator.zipKeyed(hiddenInputs).toArray(); - const nonEnumerablePadded = Iterator.zipKeyed(hiddenInputs, { mode: "longest", padding: { values: 0 } }).toArray(); + const a112 = { a: [1, 2], b: "inputs" }; + Object.defineProperty(a112, "b", { enumerable: false }); + const a113 = Iterator.zipKeyed(a112).toArray(); + const a114 = Iterator.zipKeyed(a112, { mode: "longest", padding: { a: 0 } }).toArray(); - // The same static shape can have an enumerable non-iterator property instead. - // Such inputs are accepted by the fallback and checked at runtime. - const enumerableInputs = { values: [1, 2], label: "inputs" }; - const enumerable = Iterator.zipKeyed(enumerableInputs).toArray(); + const a115 = { a: [1, 2], b: "inputs" }; + const a116 = Iterator.zipKeyed(a115).toArray(); - // The array's length and methods are not enumerable own properties. - const arrayInputs = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); + const a117 = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); - // The fallback must not claim that ignored properties exist on yielded objects. - const inheritedLabel: string = inherited[0].label; - ~~~~~~~~~~~~~~ + const a118: string = a108[0].b; + ~~~~ !!! error TS2322: Type 'unknown' is not assignable to type 'string'. - const nonEnumerableLabel: string = nonEnumerable[0].label; - ~~~~~~~~~~~~~~~~~~ + const a119: string = a113[0].b; + ~~~~ !!! error TS2322: Type 'unknown' is not assignable to type 'string'. - // Precise record inference still handles symbol keys and padding. - declare const ownKey: unique symbol; - const precise: { values: number; [ownKey]: string; }[] = Iterator.zipKeyed({ values: [1], [ownKey]: ["a"] }).toArray(); - const preciseLongest: { values: number | undefined; }[] = Iterator.zipKeyed({ values: [1] }, { mode: "longest" }).toArray(); - const precisePadded: { values: number; }[] = Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: 0 } }).toArray(); - const emptyOwnProperties: never[] = Iterator.zipKeyed({}).toArray(); + declare const a120: unique symbol; + const a121: { a: number; [a120]: string; }[] = Iterator.zipKeyed({ a: [1], [a120]: ["a"] }).toArray(); + const a122: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1] }, { mode: "longest" }).toArray(); + const a123: { a: number; }[] = Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray(); + + declare const a124: object; + const a125 = Iterator.zipKeyed(a124).toArray(); + const a126 = Iterator.zipKeyed(a124, { mode: "strict" }).toArray(); + const a127 = Iterator.zipKeyed(a124, { mode: "longest" }).toArray(); + const a128 = Iterator.zipKeyed(a124, { mode: "longest", padding: { a: 0 } }).toArray(); + const a129: unknown = a125[0].a; + const a130: unknown = a126[0].a; + const a131: unknown = a127[0].a; + const a132: unknown = a128[0].a; + const a133: never[] = a125; + ~~~~ +!!! error TS2322: Type 'Record[]' is not assignable to type 'never[]'. +!!! error TS2322: Type 'Record' is not assignable to type 'never'. + + declare const a134: {}; + const a135 = Iterator.zipKeyed(a134).toArray(); + const a136: unknown = a135[0].a; + const a137: never[] = a135; + ~~~~ +!!! error TS2322: Type 'Record[]' is not assignable to type 'never[]'. +!!! error TS2322: Type 'Record' is not assignable to type 'never'. Iterator.zipKeyed(0); ~ @@ -608,28 +622,28 @@ iteratorZip.ts(263,19): error TS2769: No overload matches this call. !!! error TS2769: The last overload gave the following error. !!! error TS2769: Argument of type 'null' is not assignable to parameter of type 'never'. !!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. - Iterator.zipKeyed(instance, { mode: "invalid" }); - ~~~~ + Iterator.zipKeyed(a107, { mode: "invalid" }); + ~~~~ !!! error TS2769: No overload matches this call. !!! error TS2769: The last overload gave the following error. !!! error TS2769: Type '"invalid"' is not assignable to type '"longest" | "shortest" | "strict" | undefined'. !!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. - Iterator.zipKeyed(instance, { mode: "shortest", padding: {} }); - ~~~~~~~ + Iterator.zipKeyed(a107, { mode: "shortest", padding: {} }); + ~~~~~~~ !!! error TS2769: No overload matches this call. !!! error TS2769: The last overload gave the following error. !!! error TS2769: Object literal may only specify known properties, and 'padding' does not exist in type 'IteratorZipShortestOptions'. !!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. - Iterator.zipKeyed(instance, { mode: "longest", padding: 0 }); - ~~~~~~~ + Iterator.zipKeyed(a107, { mode: "longest", padding: 0 }); + ~~~~~~~ !!! error TS2769: No overload matches this call. !!! error TS2769: The last overload gave the following error. !!! error TS2769: Type 'number' is not assignable to type 'object'. !!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. - Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: "invalid" } }); - ~~~~~~~~~~~~~~~ + Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: "invalid" } }); + ~~~~~~~~~~ !!! error TS2769: No overload matches this call. !!! error TS2769: The last overload gave the following error. -!!! error TS2769: Argument of type '{ values: number[]; }' is not assignable to parameter of type 'never'. +!!! error TS2769: Argument of type '{ a: number[]; }' is not assignable to parameter of type 'never'. !!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).js b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).js index f0303738a402c..c4b800dd43ba0 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).js +++ b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).js @@ -1,66 +1,66 @@ //// [tests/cases/compiler/iteratorZip.ts] //// //// [iteratorZip.ts] -declare const key: unique symbol; +declare const a1: unique symbol; -const tuples: [number, string][] = Iterator.zip([ +const a2: [number, string][] = Iterator.zip([ [1, 2], new Set(["a", "b"]), ] as const).toArray(); -tuples[0][0] = 2; +a2[0][0] = 2; -const shortestTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray(); -const strictTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray(); -const longestTuplesWithPadding: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray(); -const longestTuplesWithoutPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray(); -const longestTuplesWithPartialPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray(); +const a3: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray(); +const a4: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray(); +const a5: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray(); +const a6: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray(); +const a7: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray(); -declare const maybeLongestOptions: { mode: "shortest"; } | { mode: "longest"; }; -const maybeLongestTuples: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray(); +declare const a8: { mode: "shortest"; } | { mode: "longest"; }; +const a9: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, a8).toArray(); -const empty: never[] = Iterator.zip([]).toArray(); -const emptyLongest: never[] = Iterator.zip([], { mode: "longest" }).toArray(); +const a10: never[] = Iterator.zip([]).toArray(); +const a11: never[] = Iterator.zip([], { mode: "longest" }).toArray(); -declare const iterables: Iterable>; -const arrays: number[][] = Iterator.zip(iterables).toArray(); -const longestArrays: (number | undefined)[][] = Iterator.zip(iterables, { mode: "longest" }).toArray(); -const maybeLongestArrays: (number | undefined)[][] = Iterator.zip(iterables, maybeLongestOptions).toArray(); +declare const a12: Iterable>; +const a13: number[][] = Iterator.zip(a12).toArray(); +const a14: (number | undefined)[][] = Iterator.zip(a12, { mode: "longest" }).toArray(); +const a15: (number | undefined)[][] = Iterator.zip(a12, a8).toArray(); -declare const iterableArray: Iterable[]; -const longestArrayWithPadding: (number | undefined)[][] = Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray(); +declare const a16: Iterable[]; +const a17: (number | undefined)[][] = Iterator.zip(a16, { mode: "longest", padding: [] }).toArray(); -const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ +const a18: { a: number; b: string; [a1]: boolean; }[] = Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), - [key]: [true, false], + [a1]: [true, false], } as const).toArray(); -objects[0].a = 2; +a18[0].a = 2; -const longestObjectsWithPadding: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +const a19: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" }, }).toArray(); -const longestObjectsWithoutPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +const a20: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", }).toArray(); -const longestObjectsWithPartialPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +const a21: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" }, }).toArray(); -const maybeLongestObjects: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray(); +const a22: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, a8).toArray(); -interface Inputs { +interface I1 { a: Iterable; b: Iterator; } -declare const inputs: Inputs; -const rows: { a: number; b: string; }[] = Iterator.zipKeyed(inputs).toArray(); +declare const a23: I1; +const a24: { a: number; b: string; }[] = Iterator.zipKeyed(a23).toArray(); Iterator.zip([[1]], { mode: "invalid" }); @@ -72,13 +72,11 @@ Iterator.zip(0); Iterator.zipKeyed({ a: 0 }); -const emptyKeyed: never[] = Iterator.zipKeyed({}).toArray(); -const emptyKeyedLongest: never[] = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); +const a25: Record[] = Iterator.zipKeyed({}).toArray(); +const a26: Record[] = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); -declare const unionInputs: { a: Iterable; } | { b: Iterator; }; -const unionRows: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(unionInputs).toArray(); - -// Inputs +declare const a27: { a: Iterable; } | { b: Iterator; }; +const a28: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(a27).toArray(); Iterator.zip("ab"); Iterator.zip(["ab"]); @@ -89,55 +87,55 @@ Iterator.zip([], { mode: "longest", padding: "ab" }); Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); -const a: [string][] = Iterator.zip([new String("ab")]).toArray(); -const b: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); -const c: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); +const a29: [string][] = Iterator.zip([new String("ab")]).toArray(); +const a30: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); +const a31: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); -const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); -const e: { a: number; }[] = d; -d[0].b; -const f: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); -const g: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); +const a32 = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); +const a33: { a: number; }[] = a32; +a32[0].b; +const a34: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); +const a35: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); -interface I { +interface I2 { readonly a: Iterable; readonly b?: Iterator; readonly c: Iterable | undefined; readonly d?: undefined; } -declare const h: I; -const i = Iterator.zipKeyed(h).toArray(); -const j: { a: number; b?: string; c?: boolean; }[] = i; -i[0].a = 2; -i[0].b = "a"; -i[0].c = true; -i[0].d; -const k: { a: number; c: boolean; }[] = i; -const l: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); - -declare const m: { a: Iterable; } | { b: Iterator; }; -const n: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(m).toArray(); -declare const o: { a: Iterable; } | { b: number; }; -Iterator.zipKeyed(o); -Iterator.zipKeyed(o, { mode: "longest" }); -Iterator.zipKeyed(o, { mode: "longest", padding: {} }); -declare const p: { a?: Iterable; } | { b: string; }; -Iterator.zipKeyed(p); -declare const q: { a: Iterable; } | { b: undefined; }; -const r: { a: number; }[] = Iterator.zipKeyed(q).toArray(); - -declare const s: unique symbol; -declare const t: { a: Iterable; [s]?: Iterable; }; -const u: { a: number; [s]?: string; }[] = Iterator.zipKeyed(t).toArray(); +declare const a36: I2; +const a37 = Iterator.zipKeyed(a36).toArray(); +const a38: { a: number; b?: string; c?: boolean; }[] = a37; +a37[0].a = 2; +a37[0].b = "a"; +a37[0].c = true; +a37[0].d; +const a39: { a: number; c: boolean; }[] = a37; +const a40: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(a36, { mode: "longest" }).toArray(); + +declare const a41: { a: Iterable; } | { b: Iterator; }; +const a42: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(a41).toArray(); +declare const a43: { a: Iterable; } | { b: number; }; +Iterator.zipKeyed(a43); +Iterator.zipKeyed(a43, { mode: "longest" }); +Iterator.zipKeyed(a43, { mode: "longest", padding: {} }); +declare const a44: { a?: Iterable; } | { b: string; }; +Iterator.zipKeyed(a44); +declare const a45: { a: Iterable; } | { b: undefined; }; +const a46: { a: number; }[] = Iterator.zipKeyed(a45).toArray(); + +declare const a47: unique symbol; +declare const a48: { a: Iterable; [a47]?: Iterable; }; +const a49: { a: number; [a47]?: string; }[] = Iterator.zipKeyed(a48).toArray(); Iterator.zipKeyed({ a: [1], b: null }); Iterator.zipKeyed({ a: [1], b: false }); Iterator.zip([undefined]); -declare const v: { a?: undefined; }; -const w: never[] = Iterator.zipKeyed(v).toArray(); -const x: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); -const y: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); +declare const a50: { a?: undefined; }; +const a51: never[] = Iterator.zipKeyed(a50).toArray(); +const a52: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); +const a53: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); function f1(a: Iterable) { const b: { a: T; }[] = Iterator.zipKeyed({ a }).toArray(); @@ -145,174 +143,179 @@ function f1(a: Iterable) { return { b, c }; } -// Padding - -const paddingA: [Iterable, ...Iterable[]] = [[1, 2], [3]]; -const paddingB = Iterator.zip(paddingA, { mode: "longest", padding: [0] }).toArray(); -const paddingC: (number | undefined)[][] = paddingB; -const paddingD: number[][] = paddingB; - -const paddingE: Record> = { a: [1], b: [2, 3] }; -const paddingF = Iterator.zipKeyed(paddingE, { mode: "longest", padding: {} }).toArray(); -const paddingG: Record[] = paddingF; -const paddingH: Record[] = paddingF; - -declare const paddingI: Record; -const paddingJ = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: paddingI }).toArray(); -const paddingK: { a: number | undefined; b: number | undefined; }[] = paddingJ; -const paddingL: { a: number; b: number; }[] = paddingJ; - -const paddingM = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); -const paddingN: [number, string][] = paddingM; -const paddingO = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); -const paddingP: { a: number; b: string; }[] = paddingO; - -const paddingQ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); -const paddingR: [number | undefined, string | undefined][] = paddingQ; -const paddingS: [number, string][] = paddingQ; -const paddingT = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); -const paddingU: { a: number | undefined; b: string | undefined; }[] = paddingT; -const paddingV: { a: number; b: string; }[] = paddingT; - -declare const paddingW: readonly [number, string]; -const paddingX: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingW }).toArray(); -declare const paddingY: [number, string?]; -const paddingZ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY }).toArray(); -const paddingA1: [number, string][] = paddingZ; - -declare const paddingB1: [Iterable] | [Iterable, Iterable]; -const paddingC1 = Iterator.zip(paddingB1, { mode: "longest", padding: [0] }).toArray(); -const paddingD1: number[][] = paddingC1; -declare const paddingE1: { a: Iterable; } | { b: Iterable; }; -const paddingF1 = Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: 0 } }).toArray(); -const paddingG1: ({ a: number; } | { b: string; })[] = paddingF1; - -declare const paddingH1: { a: number; } | { b: string; }; -const paddingI1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: paddingH1 }).toArray(); -const paddingJ1: { a: number; b: string; }[] = paddingI1; - -const paddingK1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); -const paddingL1: { a: number; b: number; }[] = paddingK1; - -declare const paddingM1: { [K in `a${string}`]: Iterable; }; -const paddingN1 = Iterator.zipKeyed(paddingM1, { mode: "longest", padding: {} }).toArray(); -const paddingO1: { [K in `a${string}`]: number; }[] = paddingN1; - -declare const paddingP1: unique symbol; -const paddingQ1: { [paddingP1]: number; }[] = Iterator.zipKeyed({ [paddingP1]: [1] }, { mode: "longest", padding: { [paddingP1]: 0 } }).toArray(); - -declare const paddingR1: Record & { a: number; }; -const paddingS1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: paddingR1 }).toArray(); -const paddingT1: { a: number; b: number | undefined; }[] = paddingS1; -const paddingU1: { a: number; b: number; }[] = paddingS1; - -declare const paddingV1: [number] | [number, string]; -const paddingW1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingV1 }).toArray(); -const paddingX1: [number, string | undefined][] = paddingW1; -const paddingY1: [number, string][] = paddingW1; - -const paddingZ1: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); -const paddingA2: { a: number | undefined; b: number; }[] = paddingK1; - -// Own properties - -class InputsWithPrototypeMembers { - values = [1, 2]; - - get label() { +const a54: [Iterable, ...Iterable[]] = [[1, 2], [3]]; +const a55 = Iterator.zip(a54, { mode: "longest", padding: [0] }).toArray(); +const a56: (number | undefined)[][] = a55; +const a57: number[][] = a55; + +const a58: Record> = { a: [1], b: [2, 3] }; +const a59 = Iterator.zipKeyed(a58, { mode: "longest", padding: {} }).toArray(); +const a60: Record[] = a59; +const a61: Record[] = a59; + +declare const a62: Record; +const a63 = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a62 }).toArray(); +const a64: { a: number | undefined; b: number | undefined; }[] = a63; +const a65: { a: number; b: number; }[] = a63; + +const a66 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); +const a67: [number, string][] = a66; +const a68 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); +const a69: { a: number; b: string; }[] = a68; + +const a70 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); +const a71: [number | undefined, string | undefined][] = a70; +const a72: [number, string][] = a70; +const a73 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); +const a74: { a: number | undefined; b: string | undefined; }[] = a73; +const a75: { a: number; b: string; }[] = a73; + +declare const a76: readonly [number, string]; +const a77: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a76 }).toArray(); +declare const a78: [number, string?]; +const a79 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a78 }).toArray(); +const a80: [number, string][] = a79; + +declare const a81: [Iterable] | [Iterable, Iterable]; +const a82 = Iterator.zip(a81, { mode: "longest", padding: [0] }).toArray(); +const a83: number[][] = a82; +declare const a84: { a: Iterable; } | { b: Iterable; }; +const a85 = Iterator.zipKeyed(a84, { mode: "longest", padding: { a: 0 } }).toArray(); +const a86: ({ a: number; } | { b: string; })[] = a85; + +declare const a87: { a: number; } | { b: string; }; +const a88 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: a87 }).toArray(); +const a89: { a: number; b: string; }[] = a88; + +const a90 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); +const a91: { a: number; b: number; }[] = a90; + +declare const a92: { [K in `a${string}`]: Iterable; }; +const a93 = Iterator.zipKeyed(a92, { mode: "longest", padding: {} }).toArray(); +const a94: { [K in `a${string}`]: number; }[] = a93; + +declare const a95: unique symbol; +const a96: { [a95]: number; }[] = Iterator.zipKeyed({ [a95]: [1] }, { mode: "longest", padding: { [a95]: 0 } }).toArray(); + +declare const a97: Record & { a: number; }; +const a98 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: a97 }).toArray(); +const a99: { a: number; b: number | undefined; }[] = a98; +const a100: { a: number; b: number; }[] = a98; + +declare const a101: [number] | [number, string]; +const a102 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a101 }).toArray(); +const a103: [number, string | undefined][] = a102; +const a104: [number, string][] = a102; + +const a105: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); +const a106: { a: number | undefined; b: number; }[] = a90; + +class C1 { + a = [1, 2]; + + get b() { return "inputs"; } - describe() { - return this.label; + f() { + return this.b; } } -const instance = new InputsWithPrototypeMembers(); -const inherited = Iterator.zipKeyed(instance).toArray(); -const inheritedStrict = Iterator.zipKeyed(instance, { mode: "strict" }).toArray(); -const inheritedLongest = Iterator.zipKeyed(instance, { mode: "longest" }).toArray(); -const inheritedPadded = Iterator.zipKeyed(instance, { mode: "longest", padding: { values: 0 } }).toArray(); - -const hiddenInputs = { values: [1, 2], label: "inputs" }; -Object.defineProperty(hiddenInputs, "label", { enumerable: false }); -const nonEnumerable = Iterator.zipKeyed(hiddenInputs).toArray(); -const nonEnumerablePadded = Iterator.zipKeyed(hiddenInputs, { mode: "longest", padding: { values: 0 } }).toArray(); - -// The same static shape can have an enumerable non-iterator property instead. -// Such inputs are accepted by the fallback and checked at runtime. -const enumerableInputs = { values: [1, 2], label: "inputs" }; -const enumerable = Iterator.zipKeyed(enumerableInputs).toArray(); - -// The array's length and methods are not enumerable own properties. -const arrayInputs = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); - -// The fallback must not claim that ignored properties exist on yielded objects. -const inheritedLabel: string = inherited[0].label; -const nonEnumerableLabel: string = nonEnumerable[0].label; - -// Precise record inference still handles symbol keys and padding. -declare const ownKey: unique symbol; -const precise: { values: number; [ownKey]: string; }[] = Iterator.zipKeyed({ values: [1], [ownKey]: ["a"] }).toArray(); -const preciseLongest: { values: number | undefined; }[] = Iterator.zipKeyed({ values: [1] }, { mode: "longest" }).toArray(); -const precisePadded: { values: number; }[] = Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: 0 } }).toArray(); -const emptyOwnProperties: never[] = Iterator.zipKeyed({}).toArray(); +const a107 = new C1(); +const a108 = Iterator.zipKeyed(a107).toArray(); +const a109 = Iterator.zipKeyed(a107, { mode: "strict" }).toArray(); +const a110 = Iterator.zipKeyed(a107, { mode: "longest" }).toArray(); +const a111 = Iterator.zipKeyed(a107, { mode: "longest", padding: { a: 0 } }).toArray(); + +const a112 = { a: [1, 2], b: "inputs" }; +Object.defineProperty(a112, "b", { enumerable: false }); +const a113 = Iterator.zipKeyed(a112).toArray(); +const a114 = Iterator.zipKeyed(a112, { mode: "longest", padding: { a: 0 } }).toArray(); + +const a115 = { a: [1, 2], b: "inputs" }; +const a116 = Iterator.zipKeyed(a115).toArray(); + +const a117 = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); + +const a118: string = a108[0].b; +const a119: string = a113[0].b; + +declare const a120: unique symbol; +const a121: { a: number; [a120]: string; }[] = Iterator.zipKeyed({ a: [1], [a120]: ["a"] }).toArray(); +const a122: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1] }, { mode: "longest" }).toArray(); +const a123: { a: number; }[] = Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray(); + +declare const a124: object; +const a125 = Iterator.zipKeyed(a124).toArray(); +const a126 = Iterator.zipKeyed(a124, { mode: "strict" }).toArray(); +const a127 = Iterator.zipKeyed(a124, { mode: "longest" }).toArray(); +const a128 = Iterator.zipKeyed(a124, { mode: "longest", padding: { a: 0 } }).toArray(); +const a129: unknown = a125[0].a; +const a130: unknown = a126[0].a; +const a131: unknown = a127[0].a; +const a132: unknown = a128[0].a; +const a133: never[] = a125; + +declare const a134: {}; +const a135 = Iterator.zipKeyed(a134).toArray(); +const a136: unknown = a135[0].a; +const a137: never[] = a135; Iterator.zipKeyed(0); Iterator.zipKeyed(null); -Iterator.zipKeyed(instance, { mode: "invalid" }); -Iterator.zipKeyed(instance, { mode: "shortest", padding: {} }); -Iterator.zipKeyed(instance, { mode: "longest", padding: 0 }); -Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: "invalid" } }); +Iterator.zipKeyed(a107, { mode: "invalid" }); +Iterator.zipKeyed(a107, { mode: "shortest", padding: {} }); +Iterator.zipKeyed(a107, { mode: "longest", padding: 0 }); +Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: "invalid" } }); //// [iteratorZip.js] "use strict"; -const tuples = Iterator.zip([ +const a2 = Iterator.zip([ [1, 2], new Set(["a", "b"]), ]).toArray(); -tuples[0][0] = 2; -const shortestTuples = Iterator.zip([[1], ["a"]], { mode: "shortest" }).toArray(); -const strictTuples = Iterator.zip([[1], ["a"]], { mode: "strict" }).toArray(); -const longestTuplesWithPadding = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [1, "a"] }).toArray(); -const longestTuplesWithoutPadding = Iterator.zip([[1], ["a"]], { mode: "longest" }).toArray(); -const longestTuplesWithPartialPadding = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [1] }).toArray(); -const maybeLongestTuples = Iterator.zip([[1], ["a"]], maybeLongestOptions).toArray(); -const empty = Iterator.zip([]).toArray(); -const emptyLongest = Iterator.zip([], { mode: "longest" }).toArray(); -const arrays = Iterator.zip(iterables).toArray(); -const longestArrays = Iterator.zip(iterables, { mode: "longest" }).toArray(); -const maybeLongestArrays = Iterator.zip(iterables, maybeLongestOptions).toArray(); -const longestArrayWithPadding = Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray(); -const objects = Iterator.zipKeyed({ +a2[0][0] = 2; +const a3 = Iterator.zip([[1], ["a"]], { mode: "shortest" }).toArray(); +const a4 = Iterator.zip([[1], ["a"]], { mode: "strict" }).toArray(); +const a5 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [1, "a"] }).toArray(); +const a6 = Iterator.zip([[1], ["a"]], { mode: "longest" }).toArray(); +const a7 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [1] }).toArray(); +const a9 = Iterator.zip([[1], ["a"]], a8).toArray(); +const a10 = Iterator.zip([]).toArray(); +const a11 = Iterator.zip([], { mode: "longest" }).toArray(); +const a13 = Iterator.zip(a12).toArray(); +const a14 = Iterator.zip(a12, { mode: "longest" }).toArray(); +const a15 = Iterator.zip(a12, a8).toArray(); +const a17 = Iterator.zip(a16, { mode: "longest", padding: [] }).toArray(); +const a18 = Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), - [key]: [true, false], + [a1]: [true, false], }).toArray(); -objects[0].a = 2; -const longestObjectsWithPadding = Iterator.zipKeyed({ a: [1], b: ["a"] }, { +a18[0].a = 2; +const a19 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 1, b: "a" }, }).toArray(); -const longestObjectsWithoutPadding = Iterator.zipKeyed({ a: [1], b: ["a"] }, { +const a20 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", }).toArray(); -const longestObjectsWithPartialPadding = Iterator.zipKeyed({ a: [1], b: ["a"] }, { +const a21 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { b: "a" }, }).toArray(); -const maybeLongestObjects = Iterator.zipKeyed({ a: [1], b: ["a"] }, maybeLongestOptions).toArray(); -const rows = Iterator.zipKeyed(inputs).toArray(); +const a22 = Iterator.zipKeyed({ a: [1], b: ["a"] }, a8).toArray(); +const a24 = Iterator.zipKeyed(a23).toArray(); Iterator.zip([[1]], { mode: "invalid" }); Iterator.zip([[1], ["a"]], { mode: "longest", padding: [true] }); Iterator.zip([[1]], { mode: "shortest", padding: [1] }); Iterator.zip(0); Iterator.zipKeyed({ a: 0 }); -const emptyKeyed = Iterator.zipKeyed({}).toArray(); -const emptyKeyedLongest = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); -const unionRows = Iterator.zipKeyed(unionInputs).toArray(); -// Inputs +const a25 = Iterator.zipKeyed({}).toArray(); +const a26 = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); +const a28 = Iterator.zipKeyed(a27).toArray(); Iterator.zip("ab"); Iterator.zip(["ab"]); Iterator.zip(new Set(["ab"])); @@ -321,272 +324,278 @@ Iterator.zipKeyed({ a: "ab" }); Iterator.zip([], { mode: "longest", padding: "ab" }); Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); -const a = Iterator.zip([new String("ab")]).toArray(); -const b = Iterator.zipKeyed({ a: new String("ab") }).toArray(); -const c = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); -const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); -const e = d; -d[0].b; -const f = Iterator.zipKeyed({ a: undefined }).toArray(); -const g = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); -const i = Iterator.zipKeyed(h).toArray(); -const j = i; -i[0].a = 2; -i[0].b = "a"; -i[0].c = true; -i[0].d; -const k = i; -const l = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); -const n = Iterator.zipKeyed(m).toArray(); -Iterator.zipKeyed(o); -Iterator.zipKeyed(o, { mode: "longest" }); -Iterator.zipKeyed(o, { mode: "longest", padding: {} }); -Iterator.zipKeyed(p); -const r = Iterator.zipKeyed(q).toArray(); -const u = Iterator.zipKeyed(t).toArray(); +const a29 = Iterator.zip([new String("ab")]).toArray(); +const a30 = Iterator.zipKeyed({ a: new String("ab") }).toArray(); +const a31 = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); +const a32 = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); +const a33 = a32; +a32[0].b; +const a34 = Iterator.zipKeyed({ a: undefined }).toArray(); +const a35 = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); +const a37 = Iterator.zipKeyed(a36).toArray(); +const a38 = a37; +a37[0].a = 2; +a37[0].b = "a"; +a37[0].c = true; +a37[0].d; +const a39 = a37; +const a40 = Iterator.zipKeyed(a36, { mode: "longest" }).toArray(); +const a42 = Iterator.zipKeyed(a41).toArray(); +Iterator.zipKeyed(a43); +Iterator.zipKeyed(a43, { mode: "longest" }); +Iterator.zipKeyed(a43, { mode: "longest", padding: {} }); +Iterator.zipKeyed(a44); +const a46 = Iterator.zipKeyed(a45).toArray(); +const a49 = Iterator.zipKeyed(a48).toArray(); Iterator.zipKeyed({ a: [1], b: null }); Iterator.zipKeyed({ a: [1], b: false }); Iterator.zip([undefined]); -const w = Iterator.zipKeyed(v).toArray(); -const x = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); -const y = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); +const a51 = Iterator.zipKeyed(a50).toArray(); +const a52 = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); +const a53 = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); function f1(a) { const b = Iterator.zipKeyed({ a }).toArray(); const c = Iterator.zip([a]).toArray(); return { b, c }; } -// Padding -const paddingA = [[1, 2], [3]]; -const paddingB = Iterator.zip(paddingA, { mode: "longest", padding: [0] }).toArray(); -const paddingC = paddingB; -const paddingD = paddingB; -const paddingE = { a: [1], b: [2, 3] }; -const paddingF = Iterator.zipKeyed(paddingE, { mode: "longest", padding: {} }).toArray(); -const paddingG = paddingF; -const paddingH = paddingF; -const paddingJ = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: paddingI }).toArray(); -const paddingK = paddingJ; -const paddingL = paddingJ; -const paddingM = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); -const paddingN = paddingM; -const paddingO = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); -const paddingP = paddingO; -const paddingQ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); -const paddingR = paddingQ; -const paddingS = paddingQ; -const paddingT = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); -const paddingU = paddingT; -const paddingV = paddingT; -const paddingX = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingW }).toArray(); -const paddingZ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY }).toArray(); -const paddingA1 = paddingZ; -const paddingC1 = Iterator.zip(paddingB1, { mode: "longest", padding: [0] }).toArray(); -const paddingD1 = paddingC1; -const paddingF1 = Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: 0 } }).toArray(); -const paddingG1 = paddingF1; -const paddingI1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: paddingH1 }).toArray(); -const paddingJ1 = paddingI1; -const paddingK1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); -const paddingL1 = paddingK1; -const paddingN1 = Iterator.zipKeyed(paddingM1, { mode: "longest", padding: {} }).toArray(); -const paddingO1 = paddingN1; -const paddingQ1 = Iterator.zipKeyed({ [paddingP1]: [1] }, { mode: "longest", padding: { [paddingP1]: 0 } }).toArray(); -const paddingS1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: paddingR1 }).toArray(); -const paddingT1 = paddingS1; -const paddingU1 = paddingS1; -const paddingW1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingV1 }).toArray(); -const paddingX1 = paddingW1; -const paddingY1 = paddingW1; -const paddingZ1 = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); -const paddingA2 = paddingK1; -// Own properties -class InputsWithPrototypeMembers { - values = [1, 2]; - get label() { +const a54 = [[1, 2], [3]]; +const a55 = Iterator.zip(a54, { mode: "longest", padding: [0] }).toArray(); +const a56 = a55; +const a57 = a55; +const a58 = { a: [1], b: [2, 3] }; +const a59 = Iterator.zipKeyed(a58, { mode: "longest", padding: {} }).toArray(); +const a60 = a59; +const a61 = a59; +const a63 = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a62 }).toArray(); +const a64 = a63; +const a65 = a63; +const a66 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); +const a67 = a66; +const a68 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); +const a69 = a68; +const a70 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); +const a71 = a70; +const a72 = a70; +const a73 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); +const a74 = a73; +const a75 = a73; +const a77 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a76 }).toArray(); +const a79 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a78 }).toArray(); +const a80 = a79; +const a82 = Iterator.zip(a81, { mode: "longest", padding: [0] }).toArray(); +const a83 = a82; +const a85 = Iterator.zipKeyed(a84, { mode: "longest", padding: { a: 0 } }).toArray(); +const a86 = a85; +const a88 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: a87 }).toArray(); +const a89 = a88; +const a90 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); +const a91 = a90; +const a93 = Iterator.zipKeyed(a92, { mode: "longest", padding: {} }).toArray(); +const a94 = a93; +const a96 = Iterator.zipKeyed({ [a95]: [1] }, { mode: "longest", padding: { [a95]: 0 } }).toArray(); +const a98 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: a97 }).toArray(); +const a99 = a98; +const a100 = a98; +const a102 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a101 }).toArray(); +const a103 = a102; +const a104 = a102; +const a105 = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); +const a106 = a90; +class C1 { + a = [1, 2]; + get b() { return "inputs"; } - describe() { - return this.label; + f() { + return this.b; } } -const instance = new InputsWithPrototypeMembers(); -const inherited = Iterator.zipKeyed(instance).toArray(); -const inheritedStrict = Iterator.zipKeyed(instance, { mode: "strict" }).toArray(); -const inheritedLongest = Iterator.zipKeyed(instance, { mode: "longest" }).toArray(); -const inheritedPadded = Iterator.zipKeyed(instance, { mode: "longest", padding: { values: 0 } }).toArray(); -const hiddenInputs = { values: [1, 2], label: "inputs" }; -Object.defineProperty(hiddenInputs, "label", { enumerable: false }); -const nonEnumerable = Iterator.zipKeyed(hiddenInputs).toArray(); -const nonEnumerablePadded = Iterator.zipKeyed(hiddenInputs, { mode: "longest", padding: { values: 0 } }).toArray(); -// The same static shape can have an enumerable non-iterator property instead. -// Such inputs are accepted by the fallback and checked at runtime. -const enumerableInputs = { values: [1, 2], label: "inputs" }; -const enumerable = Iterator.zipKeyed(enumerableInputs).toArray(); -// The array's length and methods are not enumerable own properties. -const arrayInputs = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); -// The fallback must not claim that ignored properties exist on yielded objects. -const inheritedLabel = inherited[0].label; -const nonEnumerableLabel = nonEnumerable[0].label; -const precise = Iterator.zipKeyed({ values: [1], [ownKey]: ["a"] }).toArray(); -const preciseLongest = Iterator.zipKeyed({ values: [1] }, { mode: "longest" }).toArray(); -const precisePadded = Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: 0 } }).toArray(); -const emptyOwnProperties = Iterator.zipKeyed({}).toArray(); +const a107 = new C1(); +const a108 = Iterator.zipKeyed(a107).toArray(); +const a109 = Iterator.zipKeyed(a107, { mode: "strict" }).toArray(); +const a110 = Iterator.zipKeyed(a107, { mode: "longest" }).toArray(); +const a111 = Iterator.zipKeyed(a107, { mode: "longest", padding: { a: 0 } }).toArray(); +const a112 = { a: [1, 2], b: "inputs" }; +Object.defineProperty(a112, "b", { enumerable: false }); +const a113 = Iterator.zipKeyed(a112).toArray(); +const a114 = Iterator.zipKeyed(a112, { mode: "longest", padding: { a: 0 } }).toArray(); +const a115 = { a: [1, 2], b: "inputs" }; +const a116 = Iterator.zipKeyed(a115).toArray(); +const a117 = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); +const a118 = a108[0].b; +const a119 = a113[0].b; +const a121 = Iterator.zipKeyed({ a: [1], [a120]: ["a"] }).toArray(); +const a122 = Iterator.zipKeyed({ a: [1] }, { mode: "longest" }).toArray(); +const a123 = Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray(); +const a125 = Iterator.zipKeyed(a124).toArray(); +const a126 = Iterator.zipKeyed(a124, { mode: "strict" }).toArray(); +const a127 = Iterator.zipKeyed(a124, { mode: "longest" }).toArray(); +const a128 = Iterator.zipKeyed(a124, { mode: "longest", padding: { a: 0 } }).toArray(); +const a129 = a125[0].a; +const a130 = a126[0].a; +const a131 = a127[0].a; +const a132 = a128[0].a; +const a133 = a125; +const a135 = Iterator.zipKeyed(a134).toArray(); +const a136 = a135[0].a; +const a137 = a135; Iterator.zipKeyed(0); Iterator.zipKeyed(null); -Iterator.zipKeyed(instance, { mode: "invalid" }); -Iterator.zipKeyed(instance, { mode: "shortest", padding: {} }); -Iterator.zipKeyed(instance, { mode: "longest", padding: 0 }); -Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: "invalid" } }); +Iterator.zipKeyed(a107, { mode: "invalid" }); +Iterator.zipKeyed(a107, { mode: "shortest", padding: {} }); +Iterator.zipKeyed(a107, { mode: "longest", padding: 0 }); +Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: "invalid" } }); //// [iteratorZip.d.ts] -declare const key: unique symbol; -declare const tuples: [number, string][]; -declare const shortestTuples: [number, string][]; -declare const strictTuples: [number, string][]; -declare const longestTuplesWithPadding: [number, string][]; -declare const longestTuplesWithoutPadding: [number | undefined, string | undefined][]; -declare const longestTuplesWithPartialPadding: [number | undefined, string | undefined][]; -declare const maybeLongestOptions: { +declare const a1: unique symbol; +declare const a2: [number, string][]; +declare const a3: [number, string][]; +declare const a4: [number, string][]; +declare const a5: [number, string][]; +declare const a6: [number | undefined, string | undefined][]; +declare const a7: [number | undefined, string | undefined][]; +declare const a8: { mode: "shortest"; } | { mode: "longest"; }; -declare const maybeLongestTuples: [number | undefined, string | undefined][]; -declare const empty: never[]; -declare const emptyLongest: never[]; -declare const iterables: Iterable>; -declare const arrays: number[][]; -declare const longestArrays: (number | undefined)[][]; -declare const maybeLongestArrays: (number | undefined)[][]; -declare const iterableArray: Iterable[]; -declare const longestArrayWithPadding: (number | undefined)[][]; -declare const objects: { +declare const a9: [number | undefined, string | undefined][]; +declare const a10: never[]; +declare const a11: never[]; +declare const a12: Iterable>; +declare const a13: number[][]; +declare const a14: (number | undefined)[][]; +declare const a15: (number | undefined)[][]; +declare const a16: Iterable[]; +declare const a17: (number | undefined)[][]; +declare const a18: { a: number; b: string; - [key]: boolean; + [a1]: boolean; }[]; -declare const longestObjectsWithPadding: { +declare const a19: { a: number; b: string; }[]; -declare const longestObjectsWithoutPadding: { +declare const a20: { a: number | undefined; b: string | undefined; }[]; -declare const longestObjectsWithPartialPadding: { +declare const a21: { a: number | undefined; b: string | undefined; }[]; -declare const maybeLongestObjects: { +declare const a22: { a: number | undefined; b: string | undefined; }[]; -interface Inputs { +interface I1 { a: Iterable; b: Iterator; } -declare const inputs: Inputs; -declare const rows: { +declare const a23: I1; +declare const a24: { a: number; b: string; }[]; -declare const emptyKeyed: never[]; -declare const emptyKeyedLongest: never[]; -declare const unionInputs: { +declare const a25: Record[]; +declare const a26: Record[]; +declare const a27: { a: Iterable; } | { b: Iterator; }; -declare const unionRows: ({ +declare const a28: ({ a: number; } | { b: string; })[]; -declare const a: [string][]; -declare const b: { +declare const a29: [string][]; +declare const a30: { a: string; }[]; -declare const c: (string | undefined)[][]; -declare const d: { +declare const a31: (string | undefined)[][]; +declare const a32: ({ a: number; -}[]; -declare const e: { +} & {})[]; +declare const a33: { a: number; }[]; -declare const f: never[]; -declare const g: never[]; -interface I { +declare const a34: never[]; +declare const a35: never[]; +interface I2 { readonly a: Iterable; readonly b?: Iterator; readonly c: Iterable | undefined; readonly d?: undefined; } -declare const h: I; -declare const i: { +declare const a36: I2; +declare const a37: ({ a: number; +} & { b?: string | undefined; c?: boolean | undefined; -}[]; -declare const j: { +})[]; +declare const a38: { a: number; b?: string; c?: boolean; }[]; -declare const k: { +declare const a39: { a: number; c: boolean; }[]; -declare const l: { +declare const a40: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[]; -declare const m: { +declare const a41: { a: Iterable; } | { b: Iterator; }; -declare const n: ({ +declare const a42: ({ a: number; } | { b: string; })[]; -declare const o: { +declare const a43: { a: Iterable; } | { b: number; }; -declare const p: { +declare const a44: { a?: Iterable; } | { b: string; }; -declare const q: { +declare const a45: { a: Iterable; } | { b: undefined; }; -declare const r: { +declare const a46: { a: number; }[]; -declare const s: unique symbol; -declare const t: { +declare const a47: unique symbol; +declare const a48: { a: Iterable; - [s]?: Iterable; + [a47]?: Iterable; }; -declare const u: { +declare const a49: { a: number; - [s]?: string; + [a47]?: string; }[]; -declare const v: { +declare const a50: { a?: undefined; }; -declare const w: never[]; -declare const x: { +declare const a51: never[]; +declare const a52: { a: number; }[]; -declare const y: { +declare const a53: { a: number | undefined; }[]; declare function f1(a: Iterable): { @@ -595,168 +604,181 @@ declare function f1(a: Iterable): { }[]; c: [T][]; }; -declare const paddingA: [Iterable, ...Iterable[]]; -declare const paddingB: [number, ...(number | undefined)[]][]; -declare const paddingC: (number | undefined)[][]; -declare const paddingD: number[][]; -declare const paddingE: Record>; -declare const paddingF: { +declare const a54: [Iterable, ...Iterable[]]; +declare const a55: [number, ...(number | undefined)[]][]; +declare const a56: (number | undefined)[][]; +declare const a57: number[][]; +declare const a58: Record>; +declare const a59: ({ [x: string]: number | undefined; -}[]; -declare const paddingG: Record[]; -declare const paddingH: Record[]; -declare const paddingI: Record; -declare const paddingJ: { +} & {})[]; +declare const a60: Record[]; +declare const a61: Record[]; +declare const a62: Record; +declare const a63: ({ a: number | undefined; b: number | undefined; -}[]; -declare const paddingK: { +} & {})[]; +declare const a64: { a: number | undefined; b: number | undefined; }[]; -declare const paddingL: { +declare const a65: { a: number; b: number; }[]; -declare const paddingM: [number, string][]; -declare const paddingN: [number, string][]; -declare const paddingO: { +declare const a66: [number, string][]; +declare const a67: [number, string][]; +declare const a68: ({ a: number; b: string; -}[]; -declare const paddingP: { +} & {})[]; +declare const a69: { a: number; b: string; }[]; -declare const paddingQ: [number, string | undefined][]; -declare const paddingR: [number | undefined, string | undefined][]; -declare const paddingS: [number, string][]; -declare const paddingT: { +declare const a70: [number, string | undefined][]; +declare const a71: [number | undefined, string | undefined][]; +declare const a72: [number, string][]; +declare const a73: ({ a: number; b: string | undefined; -}[]; -declare const paddingU: { +} & {})[]; +declare const a74: { a: number | undefined; b: string | undefined; }[]; -declare const paddingV: { +declare const a75: { a: number; b: string; }[]; -declare const paddingW: readonly [number, string]; -declare const paddingX: [number, string][]; -declare const paddingY: [number, string?]; -declare const paddingZ: [number, string | undefined][]; -declare const paddingA1: [number, string][]; -declare const paddingB1: [Iterable] | [Iterable, Iterable]; -declare const paddingC1: ([number] | [number, number | undefined])[]; -declare const paddingD1: number[][]; -declare const paddingE1: { +declare const a76: readonly [number, string]; +declare const a77: [number, string][]; +declare const a78: [number, string?]; +declare const a79: [number, string | undefined][]; +declare const a80: [number, string][]; +declare const a81: [Iterable] | [Iterable, Iterable]; +declare const a82: ([number] | [number, number | undefined])[]; +declare const a83: number[][]; +declare const a84: { a: Iterable; } | { b: Iterable; }; -declare const paddingF1: ({ +declare const a85: (({ a: number; -} | { +} & {}) | ({ b: string | undefined; -})[]; -declare const paddingG1: ({ +} & {}))[]; +declare const a86: ({ a: number; } | { b: string; })[]; -declare const paddingH1: { +declare const a87: { a: number; } | { b: string; }; -declare const paddingI1: { +declare const a88: ({ a: number | undefined; b: string | undefined; -}[]; -declare const paddingJ1: { +} & {})[]; +declare const a89: { a: number; b: string; }[]; -declare const paddingK1: { +declare const a90: ({ a: number | undefined; b: number; -}[]; -declare const paddingL1: { +} & {})[]; +declare const a91: { a: number; b: number; }[]; -declare const paddingM1: { +declare const a92: { [K in `a${string}`]: Iterable; }; -declare const paddingN1: { +declare const a93: ({ [x: `a${string}`]: number | undefined; -}[]; -declare const paddingO1: { +} & {})[]; +declare const a94: { [K in `a${string}`]: number; }[]; -declare const paddingP1: unique symbol; -declare const paddingQ1: { - [paddingP1]: number; +declare const a95: unique symbol; +declare const a96: { + [a95]: number; }[]; -declare const paddingR1: Record & { +declare const a97: Record & { a: number; }; -declare const paddingS1: { +declare const a98: ({ a: number; b: number | undefined; -}[]; -declare const paddingT1: { +} & {})[]; +declare const a99: { a: number; b: number | undefined; }[]; -declare const paddingU1: { +declare const a100: { a: number; b: number; }[]; -declare const paddingV1: [number] | [number, string]; -declare const paddingW1: [number, string | undefined][]; -declare const paddingX1: [number, string | undefined][]; -declare const paddingY1: [number, string][]; -declare const paddingZ1: [number | undefined, number][]; -declare const paddingA2: { +declare const a101: [number] | [number, string]; +declare const a102: [number, string | undefined][]; +declare const a103: [number, string | undefined][]; +declare const a104: [number, string][]; +declare const a105: [number | undefined, number][]; +declare const a106: { a: number | undefined; b: number; }[]; -declare class InputsWithPrototypeMembers { - values: number[]; - get label(): string; - describe(): string; +declare class C1 { + a: number[]; + get b(): string; + f(): string; } -declare const instance: InputsWithPrototypeMembers; -declare const inherited: Record[]; -declare const inheritedStrict: Record[]; -declare const inheritedLongest: Record[]; -declare const inheritedPadded: Record[]; -declare const hiddenInputs: { - values: number[]; - label: string; +declare const a107: C1; +declare const a108: Record[]; +declare const a109: Record[]; +declare const a110: Record[]; +declare const a111: Record[]; +declare const a112: { + a: number[]; + b: string; }; -declare const nonEnumerable: Record[]; -declare const nonEnumerablePadded: Record[]; -declare const enumerableInputs: { - values: number[]; - label: string; +declare const a113: Record[]; +declare const a114: Record[]; +declare const a115: { + a: number[]; + b: string; }; -declare const enumerable: Record[]; -declare const arrayInputs: Record[]; -declare const inheritedLabel: string; -declare const nonEnumerableLabel: string; -declare const ownKey: unique symbol; -declare const precise: { - values: number; - [ownKey]: string; +declare const a116: Record[]; +declare const a117: Record[]; +declare const a118: string; +declare const a119: string; +declare const a120: unique symbol; +declare const a121: { + a: number; + [a120]: string; }[]; -declare const preciseLongest: { - values: number | undefined; +declare const a122: { + a: number | undefined; }[]; -declare const precisePadded: { - values: number; +declare const a123: { + a: number; }[]; -declare const emptyOwnProperties: never[]; +declare const a124: object; +declare const a125: Record[]; +declare const a126: Record[]; +declare const a127: Record[]; +declare const a128: Record[]; +declare const a129: unknown; +declare const a130: unknown; +declare const a131: unknown; +declare const a132: unknown; +declare const a133: never[]; +declare const a134: {}; +declare const a135: Record[]; +declare const a136: unknown; +declare const a137: never[]; diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).symbols b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).symbols index 3314b80fc616e..14821dd34b801 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).symbols +++ b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).symbols @@ -1,11 +1,11 @@ //// [tests/cases/compiler/iteratorZip.ts] //// === iteratorZip.ts === -declare const key: unique symbol; ->key : Symbol(key, Decl(iteratorZip.ts, 0, 13)) +declare const a1: unique symbol; +>a1 : Symbol(a1, Decl(iteratorZip.ts, 0, 13)) -const tuples: [number, string][] = Iterator.zip([ ->tuples : Symbol(tuples, Decl(iteratorZip.ts, 2, 5)) +const a2: [number, string][] = Iterator.zip([ +>a2 : Symbol(a2, Decl(iteratorZip.ts, 2, 5)) >Iterator.zip([ [1, 2], new Set(["a", "b"]),] as const).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) @@ -19,188 +19,188 @@ const tuples: [number, string][] = Iterator.zip([ >const : Symbol(const) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -tuples[0][0] = 2; ->tuples : Symbol(tuples, Decl(iteratorZip.ts, 2, 5)) +a2[0][0] = 2; +>a2 : Symbol(a2, Decl(iteratorZip.ts, 2, 5)) >0 : Symbol(0) -const shortestTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray(); ->shortestTuples : Symbol(shortestTuples, Decl(iteratorZip.ts, 9, 5)) +const a3: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray(); +>a3 : Symbol(a3, Decl(iteratorZip.ts, 9, 5)) >Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >const : Symbol(const) ->mode : Symbol(mode, Decl(iteratorZip.ts, 9, 80)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 9, 68)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const strictTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray(); ->strictTuples : Symbol(strictTuples, Decl(iteratorZip.ts, 10, 5)) +const a4: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray(); +>a4 : Symbol(a4, Decl(iteratorZip.ts, 10, 5)) >Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >const : Symbol(const) ->mode : Symbol(mode, Decl(iteratorZip.ts, 10, 78)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 10, 68)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const longestTuplesWithPadding: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray(); ->longestTuplesWithPadding : Symbol(longestTuplesWithPadding, Decl(iteratorZip.ts, 11, 5)) +const a5: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray(); +>a5 : Symbol(a5, Decl(iteratorZip.ts, 11, 5)) >Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >const : Symbol(const) ->mode : Symbol(mode, Decl(iteratorZip.ts, 11, 90)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 11, 107)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 11, 68)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 11, 85)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const longestTuplesWithoutPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray(); ->longestTuplesWithoutPadding : Symbol(longestTuplesWithoutPadding, Decl(iteratorZip.ts, 12, 5)) +const a6: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray(); +>a6 : Symbol(a6, Decl(iteratorZip.ts, 12, 5)) >Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >const : Symbol(const) ->mode : Symbol(mode, Decl(iteratorZip.ts, 12, 117)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 12, 92)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const longestTuplesWithPartialPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray(); ->longestTuplesWithPartialPadding : Symbol(longestTuplesWithPartialPadding, Decl(iteratorZip.ts, 13, 5)) +const a7: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray(); +>a7 : Symbol(a7, Decl(iteratorZip.ts, 13, 5)) >Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >const : Symbol(const) ->mode : Symbol(mode, Decl(iteratorZip.ts, 13, 121)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 13, 138)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 13, 92)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 13, 109)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -declare const maybeLongestOptions: { mode: "shortest"; } | { mode: "longest"; }; ->maybeLongestOptions : Symbol(maybeLongestOptions, Decl(iteratorZip.ts, 15, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 15, 36)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 15, 60)) +declare const a8: { mode: "shortest"; } | { mode: "longest"; }; +>a8 : Symbol(a8, Decl(iteratorZip.ts, 15, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 15, 19)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 15, 43)) -const maybeLongestTuples: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray(); ->maybeLongestTuples : Symbol(maybeLongestTuples, Decl(iteratorZip.ts, 16, 5)) ->Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a9: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, a8).toArray(); +>a9 : Symbol(a9, Decl(iteratorZip.ts, 16, 5)) +>Iterator.zip([[1], ["a"]] as const, a8).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >const : Symbol(const) ->maybeLongestOptions : Symbol(maybeLongestOptions, Decl(iteratorZip.ts, 15, 13)) +>a8 : Symbol(a8, Decl(iteratorZip.ts, 15, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const empty: never[] = Iterator.zip([]).toArray(); ->empty : Symbol(empty, Decl(iteratorZip.ts, 18, 5)) +const a10: never[] = Iterator.zip([]).toArray(); +>a10 : Symbol(a10, Decl(iteratorZip.ts, 18, 5)) >Iterator.zip([]).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const emptyLongest: never[] = Iterator.zip([], { mode: "longest" }).toArray(); ->emptyLongest : Symbol(emptyLongest, Decl(iteratorZip.ts, 19, 5)) +const a11: never[] = Iterator.zip([], { mode: "longest" }).toArray(); +>a11 : Symbol(a11, Decl(iteratorZip.ts, 19, 5)) >Iterator.zip([], { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 19, 48)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 19, 39)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -declare const iterables: Iterable>; ->iterables : Symbol(iterables, Decl(iteratorZip.ts, 21, 13)) +declare const a12: Iterable>; +>a12 : Symbol(a12, Decl(iteratorZip.ts, 21, 13)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) -const arrays: number[][] = Iterator.zip(iterables).toArray(); ->arrays : Symbol(arrays, Decl(iteratorZip.ts, 22, 5)) ->Iterator.zip(iterables).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a13: number[][] = Iterator.zip(a12).toArray(); +>a13 : Symbol(a13, Decl(iteratorZip.ts, 22, 5)) +>Iterator.zip(a12).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->iterables : Symbol(iterables, Decl(iteratorZip.ts, 21, 13)) +>a12 : Symbol(a12, Decl(iteratorZip.ts, 21, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const longestArrays: (number | undefined)[][] = Iterator.zip(iterables, { mode: "longest" }).toArray(); ->longestArrays : Symbol(longestArrays, Decl(iteratorZip.ts, 23, 5)) ->Iterator.zip(iterables, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a14: (number | undefined)[][] = Iterator.zip(a12, { mode: "longest" }).toArray(); +>a14 : Symbol(a14, Decl(iteratorZip.ts, 23, 5)) +>Iterator.zip(a12, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->iterables : Symbol(iterables, Decl(iteratorZip.ts, 21, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 23, 73)) +>a12 : Symbol(a12, Decl(iteratorZip.ts, 21, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 23, 57)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const maybeLongestArrays: (number | undefined)[][] = Iterator.zip(iterables, maybeLongestOptions).toArray(); ->maybeLongestArrays : Symbol(maybeLongestArrays, Decl(iteratorZip.ts, 24, 5)) ->Iterator.zip(iterables, maybeLongestOptions).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a15: (number | undefined)[][] = Iterator.zip(a12, a8).toArray(); +>a15 : Symbol(a15, Decl(iteratorZip.ts, 24, 5)) +>Iterator.zip(a12, a8).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->iterables : Symbol(iterables, Decl(iteratorZip.ts, 21, 13)) ->maybeLongestOptions : Symbol(maybeLongestOptions, Decl(iteratorZip.ts, 15, 13)) +>a12 : Symbol(a12, Decl(iteratorZip.ts, 21, 13)) +>a8 : Symbol(a8, Decl(iteratorZip.ts, 15, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -declare const iterableArray: Iterable[]; ->iterableArray : Symbol(iterableArray, Decl(iteratorZip.ts, 26, 13)) +declare const a16: Iterable[]; +>a16 : Symbol(a16, Decl(iteratorZip.ts, 26, 13)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) -const longestArrayWithPadding: (number | undefined)[][] = Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray(); ->longestArrayWithPadding : Symbol(longestArrayWithPadding, Decl(iteratorZip.ts, 27, 5)) ->Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a17: (number | undefined)[][] = Iterator.zip(a16, { mode: "longest", padding: [] }).toArray(); +>a17 : Symbol(a17, Decl(iteratorZip.ts, 27, 5)) +>Iterator.zip(a16, { mode: "longest", padding: [] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->iterableArray : Symbol(iterableArray, Decl(iteratorZip.ts, 26, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 27, 87)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 27, 104)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ ->objects : Symbol(objects, Decl(iteratorZip.ts, 29, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 29, 16)) ->b : Symbol(b, Decl(iteratorZip.ts, 29, 27)) ->[key] : Symbol([key], Decl(iteratorZip.ts, 29, 38)) ->key : Symbol(key, Decl(iteratorZip.ts, 0, 13)) ->Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>a16 : Symbol(a16, Decl(iteratorZip.ts, 26, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 27, 57)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 27, 74)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a18: { a: number; b: string; [a1]: boolean; }[] = Iterator.zipKeyed({ +>a18 : Symbol(a18, Decl(iteratorZip.ts, 29, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 29, 12)) +>b : Symbol(b, Decl(iteratorZip.ts, 29, 23)) +>[a1] : Symbol([a1], Decl(iteratorZip.ts, 29, 34)) +>a1 : Symbol(a1, Decl(iteratorZip.ts, 0, 13)) +>Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [a1]: [true, false],} as const).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) a: [1, 2], ->a : Symbol(a, Decl(iteratorZip.ts, 29, 80)) +>a : Symbol(a, Decl(iteratorZip.ts, 29, 75)) b: new Set(["a", "b"]), >b : Symbol(b, Decl(iteratorZip.ts, 30, 14)) >Set : Symbol(Set, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) - [key]: [true, false], ->[key] : Symbol([key], Decl(iteratorZip.ts, 31, 27)) ->key : Symbol(key, Decl(iteratorZip.ts, 0, 13)) + [a1]: [true, false], +>[a1] : Symbol([a1], Decl(iteratorZip.ts, 31, 27)) +>a1 : Symbol(a1, Decl(iteratorZip.ts, 0, 13)) } as const).toArray(); >const : Symbol(const) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -objects[0].a = 2; ->objects[0].a : Symbol(a, Decl(iteratorZip.ts, 29, 16)) ->objects : Symbol(objects, Decl(iteratorZip.ts, 29, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 29, 16)) +a18[0].a = 2; +>a18[0].a : Symbol(a, Decl(iteratorZip.ts, 29, 12)) +>a18 : Symbol(a18, Decl(iteratorZip.ts, 29, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 29, 12)) -const longestObjectsWithPadding: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { ->longestObjectsWithPadding : Symbol(longestObjectsWithPadding, Decl(iteratorZip.ts, 37, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 37, 34)) ->b : Symbol(b, Decl(iteratorZip.ts, 37, 45)) +const a19: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +>a19 : Symbol(a19, Decl(iteratorZip.ts, 37, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 37, 12)) +>b : Symbol(b, Decl(iteratorZip.ts, 37, 23)) >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 37, 82)) ->b : Symbol(b, Decl(iteratorZip.ts, 37, 90)) +>a : Symbol(a, Decl(iteratorZip.ts, 37, 60)) +>b : Symbol(b, Decl(iteratorZip.ts, 37, 68)) >const : Symbol(const) mode: "longest", ->mode : Symbol(mode, Decl(iteratorZip.ts, 37, 113)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 37, 91)) padding: { a: 1, b: "a" }, >padding : Symbol(padding, Decl(iteratorZip.ts, 38, 20)) @@ -210,38 +210,38 @@ const longestObjectsWithPadding: { a: number; b: string; }[] = Iterator.zipKeyed }).toArray(); >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const longestObjectsWithoutPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { ->longestObjectsWithoutPadding : Symbol(longestObjectsWithoutPadding, Decl(iteratorZip.ts, 42, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 42, 37)) ->b : Symbol(b, Decl(iteratorZip.ts, 42, 60)) +const a20: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +>a20 : Symbol(a20, Decl(iteratorZip.ts, 42, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 42, 12)) +>b : Symbol(b, Decl(iteratorZip.ts, 42, 35)) >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 42, 109)) ->b : Symbol(b, Decl(iteratorZip.ts, 42, 117)) +>a : Symbol(a, Decl(iteratorZip.ts, 42, 84)) +>b : Symbol(b, Decl(iteratorZip.ts, 42, 92)) >const : Symbol(const) mode: "longest", ->mode : Symbol(mode, Decl(iteratorZip.ts, 42, 140)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 42, 115)) }).toArray(); >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const longestObjectsWithPartialPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { ->longestObjectsWithPartialPadding : Symbol(longestObjectsWithPartialPadding, Decl(iteratorZip.ts, 46, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 46, 41)) ->b : Symbol(b, Decl(iteratorZip.ts, 46, 64)) +const a21: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +>a21 : Symbol(a21, Decl(iteratorZip.ts, 46, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 46, 12)) +>b : Symbol(b, Decl(iteratorZip.ts, 46, 35)) >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 46, 113)) ->b : Symbol(b, Decl(iteratorZip.ts, 46, 121)) +>a : Symbol(a, Decl(iteratorZip.ts, 46, 84)) +>b : Symbol(b, Decl(iteratorZip.ts, 46, 92)) >const : Symbol(const) mode: "longest", ->mode : Symbol(mode, Decl(iteratorZip.ts, 46, 144)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 46, 115)) padding: { b: "a" }, >padding : Symbol(padding, Decl(iteratorZip.ts, 47, 20)) @@ -250,45 +250,45 @@ const longestObjectsWithPartialPadding: { a: number | undefined; b: string | und }).toArray(); >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const maybeLongestObjects: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray(); ->maybeLongestObjects : Symbol(maybeLongestObjects, Decl(iteratorZip.ts, 51, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 51, 28)) ->b : Symbol(b, Decl(iteratorZip.ts, 51, 51)) ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a22: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, a8).toArray(); +>a22 : Symbol(a22, Decl(iteratorZip.ts, 51, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 51, 12)) +>b : Symbol(b, Decl(iteratorZip.ts, 51, 35)) +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, a8).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 51, 100)) ->b : Symbol(b, Decl(iteratorZip.ts, 51, 108)) +>a : Symbol(a, Decl(iteratorZip.ts, 51, 84)) +>b : Symbol(b, Decl(iteratorZip.ts, 51, 92)) >const : Symbol(const) ->maybeLongestOptions : Symbol(maybeLongestOptions, Decl(iteratorZip.ts, 15, 13)) +>a8 : Symbol(a8, Decl(iteratorZip.ts, 15, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -interface Inputs { ->Inputs : Symbol(Inputs, Decl(iteratorZip.ts, 51, 161)) +interface I1 { +>I1 : Symbol(I1, Decl(iteratorZip.ts, 51, 128)) a: Iterable; ->a : Symbol(Inputs.a, Decl(iteratorZip.ts, 53, 18)) +>a : Symbol(I1.a, Decl(iteratorZip.ts, 53, 14)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) b: Iterator; ->b : Symbol(Inputs.b, Decl(iteratorZip.ts, 54, 24)) +>b : Symbol(I1.b, Decl(iteratorZip.ts, 54, 24)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) } -declare const inputs: Inputs; ->inputs : Symbol(inputs, Decl(iteratorZip.ts, 58, 13)) ->Inputs : Symbol(Inputs, Decl(iteratorZip.ts, 51, 161)) +declare const a23: I1; +>a23 : Symbol(a23, Decl(iteratorZip.ts, 58, 13)) +>I1 : Symbol(I1, Decl(iteratorZip.ts, 51, 128)) -const rows: { a: number; b: string; }[] = Iterator.zipKeyed(inputs).toArray(); ->rows : Symbol(rows, Decl(iteratorZip.ts, 59, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 59, 13)) ->b : Symbol(b, Decl(iteratorZip.ts, 59, 24)) ->Iterator.zipKeyed(inputs).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a24: { a: number; b: string; }[] = Iterator.zipKeyed(a23).toArray(); +>a24 : Symbol(a24, Decl(iteratorZip.ts, 59, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 59, 12)) +>b : Symbol(b, Decl(iteratorZip.ts, 59, 23)) +>Iterator.zipKeyed(a23).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->inputs : Symbol(inputs, Decl(iteratorZip.ts, 58, 13)) +>a23 : Symbol(a23, Decl(iteratorZip.ts, 58, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) Iterator.zip([[1]], { mode: "invalid" }); @@ -323,44 +323,46 @@ Iterator.zipKeyed({ a: 0 }); >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >a : Symbol(a, Decl(iteratorZip.ts, 69, 19)) -const emptyKeyed: never[] = Iterator.zipKeyed({}).toArray(); ->emptyKeyed : Symbol(emptyKeyed, Decl(iteratorZip.ts, 71, 5)) +const a25: Record[] = Iterator.zipKeyed({}).toArray(); +>a25 : Symbol(a25, Decl(iteratorZip.ts, 71, 5)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>PropertyKey : Symbol(PropertyKey, Decl(lib.es5.d.ts, --, --)) >Iterator.zipKeyed({}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const emptyKeyedLongest: never[] = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); ->emptyKeyedLongest : Symbol(emptyKeyedLongest, Decl(iteratorZip.ts, 72, 5)) +const a26: Record[] = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); +>a26 : Symbol(a26, Decl(iteratorZip.ts, 72, 5)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>PropertyKey : Symbol(PropertyKey, Decl(lib.es5.d.ts, --, --)) >Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 72, 58)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 72, 75)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 72, 67)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 72, 84)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -declare const unionInputs: { a: Iterable; } | { b: Iterator; }; ->unionInputs : Symbol(unionInputs, Decl(iteratorZip.ts, 74, 13)) ->a : Symbol(a, Decl(iteratorZip.ts, 74, 28)) +declare const a27: { a: Iterable; } | { b: Iterator; }; +>a27 : Symbol(a27, Decl(iteratorZip.ts, 74, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 74, 20)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->b : Symbol(b, Decl(iteratorZip.ts, 74, 55)) +>b : Symbol(b, Decl(iteratorZip.ts, 74, 47)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) -const unionRows: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(unionInputs).toArray(); ->unionRows : Symbol(unionRows, Decl(iteratorZip.ts, 75, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 75, 19)) ->b : Symbol(b, Decl(iteratorZip.ts, 75, 36)) ->Iterator.zipKeyed(unionInputs).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a28: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(a27).toArray(); +>a28 : Symbol(a28, Decl(iteratorZip.ts, 75, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 75, 13)) +>b : Symbol(b, Decl(iteratorZip.ts, 75, 30)) +>Iterator.zipKeyed(a27).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->unionInputs : Symbol(unionInputs, Decl(iteratorZip.ts, 74, 13)) +>a27 : Symbol(a27, Decl(iteratorZip.ts, 74, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -// Inputs - Iterator.zip("ab"); >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) @@ -386,31 +388,31 @@ Iterator.zipKeyed({ a: "ab" }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 83, 19)) +>a : Symbol(a, Decl(iteratorZip.ts, 81, 19)) Iterator.zip([], { mode: "longest", padding: "ab" }); >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 84, 18)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 84, 35)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 82, 18)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 82, 35)) Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 85, 23)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 85, 40)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 83, 23)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 83, 40)) Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 86, 23)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 86, 40)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 84, 23)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 84, 40)) -const a: [string][] = Iterator.zip([new String("ab")]).toArray(); ->a : Symbol(a, Decl(iteratorZip.ts, 88, 5)) +const a29: [string][] = Iterator.zip([new String("ab")]).toArray(); +>a29 : Symbol(a29, Decl(iteratorZip.ts, 86, 5)) >Iterator.zip([new String("ab")]).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) @@ -418,253 +420,253 @@ const a: [string][] = Iterator.zip([new String("ab")]).toArray(); >String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const b: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); ->b : Symbol(b, Decl(iteratorZip.ts, 89, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 89, 10)) +const a30: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); +>a30 : Symbol(a30, Decl(iteratorZip.ts, 87, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 87, 12)) >Iterator.zipKeyed({ a: new String("ab") }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 89, 47)) +>a : Symbol(a, Decl(iteratorZip.ts, 87, 49)) >String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const c: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); ->c : Symbol(c, Decl(iteratorZip.ts, 90, 5)) +const a31: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); +>a31 : Symbol(a31, Decl(iteratorZip.ts, 88, 5)) >Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 90, 59)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 90, 76)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 88, 61)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 88, 78)) >String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); ->d : Symbol(d, Decl(iteratorZip.ts, 92, 5)) +const a32 = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); +>a32 : Symbol(a32, Decl(iteratorZip.ts, 90, 5)) >Iterator.zipKeyed({ a: [1], b: undefined }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 92, 29)) ->b : Symbol(b, Decl(iteratorZip.ts, 92, 37)) +>a : Symbol(a, Decl(iteratorZip.ts, 90, 31)) +>b : Symbol(b, Decl(iteratorZip.ts, 90, 39)) >undefined : Symbol(undefined) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const e: { a: number; }[] = d; ->e : Symbol(e, Decl(iteratorZip.ts, 93, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 93, 10)) ->d : Symbol(d, Decl(iteratorZip.ts, 92, 5)) +const a33: { a: number; }[] = a32; +>a33 : Symbol(a33, Decl(iteratorZip.ts, 91, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 91, 12)) +>a32 : Symbol(a32, Decl(iteratorZip.ts, 90, 5)) -d[0].b; ->d : Symbol(d, Decl(iteratorZip.ts, 92, 5)) +a32[0].b; +>a32 : Symbol(a32, Decl(iteratorZip.ts, 90, 5)) -const f: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); ->f : Symbol(f, Decl(iteratorZip.ts, 95, 5)) +const a34: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); +>a34 : Symbol(a34, Decl(iteratorZip.ts, 93, 5)) >Iterator.zipKeyed({ a: undefined }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 95, 38)) +>a : Symbol(a, Decl(iteratorZip.ts, 93, 40)) >undefined : Symbol(undefined) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const g: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); ->g : Symbol(g, Decl(iteratorZip.ts, 96, 5)) +const a35: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); +>a35 : Symbol(a35, Decl(iteratorZip.ts, 94, 5)) >Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 96, 38)) +>a : Symbol(a, Decl(iteratorZip.ts, 94, 40)) >undefined : Symbol(undefined) ->mode : Symbol(mode, Decl(iteratorZip.ts, 96, 56)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 96, 73)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 94, 58)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 94, 75)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -interface I { ->I : Symbol(I, Decl(iteratorZip.ts, 96, 99)) +interface I2 { +>I2 : Symbol(I2, Decl(iteratorZip.ts, 94, 101)) readonly a: Iterable; ->a : Symbol(I.a, Decl(iteratorZip.ts, 98, 13)) +>a : Symbol(I2.a, Decl(iteratorZip.ts, 96, 14)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) readonly b?: Iterator; ->b : Symbol(I.b, Decl(iteratorZip.ts, 99, 33)) +>b : Symbol(I2.b, Decl(iteratorZip.ts, 97, 33)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) readonly c: Iterable | undefined; ->c : Symbol(I.c, Decl(iteratorZip.ts, 100, 34)) +>c : Symbol(I2.c, Decl(iteratorZip.ts, 98, 34)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) readonly d?: undefined; ->d : Symbol(I.d, Decl(iteratorZip.ts, 101, 46)) +>d : Symbol(I2.d, Decl(iteratorZip.ts, 99, 46)) } -declare const h: I; ->h : Symbol(h, Decl(iteratorZip.ts, 104, 13)) ->I : Symbol(I, Decl(iteratorZip.ts, 96, 99)) +declare const a36: I2; +>a36 : Symbol(a36, Decl(iteratorZip.ts, 102, 13)) +>I2 : Symbol(I2, Decl(iteratorZip.ts, 94, 101)) -const i = Iterator.zipKeyed(h).toArray(); ->i : Symbol(i, Decl(iteratorZip.ts, 105, 5)) ->Iterator.zipKeyed(h).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a37 = Iterator.zipKeyed(a36).toArray(); +>a37 : Symbol(a37, Decl(iteratorZip.ts, 103, 5)) +>Iterator.zipKeyed(a36).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->h : Symbol(h, Decl(iteratorZip.ts, 104, 13)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const j: { a: number; b?: string; c?: boolean; }[] = i; ->j : Symbol(j, Decl(iteratorZip.ts, 106, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 106, 10)) ->b : Symbol(b, Decl(iteratorZip.ts, 106, 21)) ->c : Symbol(c, Decl(iteratorZip.ts, 106, 33)) ->i : Symbol(i, Decl(iteratorZip.ts, 105, 5)) - -i[0].a = 2; ->i[0].a : Symbol(a, Decl(iteratorZip.ts, 98, 13)) ->i : Symbol(i, Decl(iteratorZip.ts, 105, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 98, 13)) - -i[0].b = "a"; ->i[0].b : Symbol(b, Decl(iteratorZip.ts, 99, 33)) ->i : Symbol(i, Decl(iteratorZip.ts, 105, 5)) ->b : Symbol(b, Decl(iteratorZip.ts, 99, 33)) - -i[0].c = true; ->i[0].c : Symbol(c, Decl(iteratorZip.ts, 100, 34)) ->i : Symbol(i, Decl(iteratorZip.ts, 105, 5)) ->c : Symbol(c, Decl(iteratorZip.ts, 100, 34)) - -i[0].d; ->i : Symbol(i, Decl(iteratorZip.ts, 105, 5)) - -const k: { a: number; c: boolean; }[] = i; ->k : Symbol(k, Decl(iteratorZip.ts, 111, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 111, 10)) ->c : Symbol(c, Decl(iteratorZip.ts, 111, 21)) ->i : Symbol(i, Decl(iteratorZip.ts, 105, 5)) - -const l: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); ->l : Symbol(l, Decl(iteratorZip.ts, 112, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 112, 10)) ->b : Symbol(b, Decl(iteratorZip.ts, 112, 33)) ->c : Symbol(c, Decl(iteratorZip.ts, 112, 57)) ->Iterator.zipKeyed(h, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>a36 : Symbol(a36, Decl(iteratorZip.ts, 102, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a38: { a: number; b?: string; c?: boolean; }[] = a37; +>a38 : Symbol(a38, Decl(iteratorZip.ts, 104, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 104, 12)) +>b : Symbol(b, Decl(iteratorZip.ts, 104, 23)) +>c : Symbol(c, Decl(iteratorZip.ts, 104, 35)) +>a37 : Symbol(a37, Decl(iteratorZip.ts, 103, 5)) + +a37[0].a = 2; +>a37[0].a : Symbol(a, Decl(iteratorZip.ts, 96, 14)) +>a37 : Symbol(a37, Decl(iteratorZip.ts, 103, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 96, 14)) + +a37[0].b = "a"; +>a37[0].b : Symbol(b, Decl(iteratorZip.ts, 97, 33)) +>a37 : Symbol(a37, Decl(iteratorZip.ts, 103, 5)) +>b : Symbol(b, Decl(iteratorZip.ts, 97, 33)) + +a37[0].c = true; +>a37[0].c : Symbol(c, Decl(iteratorZip.ts, 98, 34)) +>a37 : Symbol(a37, Decl(iteratorZip.ts, 103, 5)) +>c : Symbol(c, Decl(iteratorZip.ts, 98, 34)) + +a37[0].d; +>a37 : Symbol(a37, Decl(iteratorZip.ts, 103, 5)) + +const a39: { a: number; c: boolean; }[] = a37; +>a39 : Symbol(a39, Decl(iteratorZip.ts, 109, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 109, 12)) +>c : Symbol(c, Decl(iteratorZip.ts, 109, 23)) +>a37 : Symbol(a37, Decl(iteratorZip.ts, 103, 5)) + +const a40: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(a36, { mode: "longest" }).toArray(); +>a40 : Symbol(a40, Decl(iteratorZip.ts, 110, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 110, 12)) +>b : Symbol(b, Decl(iteratorZip.ts, 110, 35)) +>c : Symbol(c, Decl(iteratorZip.ts, 110, 59)) +>Iterator.zipKeyed(a36, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->h : Symbol(h, Decl(iteratorZip.ts, 104, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 112, 111)) +>a36 : Symbol(a36, Decl(iteratorZip.ts, 102, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 110, 115)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -declare const m: { a: Iterable; } | { b: Iterator; }; ->m : Symbol(m, Decl(iteratorZip.ts, 114, 13)) ->a : Symbol(a, Decl(iteratorZip.ts, 114, 18)) +declare const a41: { a: Iterable; } | { b: Iterator; }; +>a41 : Symbol(a41, Decl(iteratorZip.ts, 112, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 112, 20)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->b : Symbol(b, Decl(iteratorZip.ts, 114, 45)) +>b : Symbol(b, Decl(iteratorZip.ts, 112, 47)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) -const n: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(m).toArray(); ->n : Symbol(n, Decl(iteratorZip.ts, 115, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 115, 11)) ->b : Symbol(b, Decl(iteratorZip.ts, 115, 28)) ->Iterator.zipKeyed(m).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a42: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(a41).toArray(); +>a42 : Symbol(a42, Decl(iteratorZip.ts, 113, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 113, 13)) +>b : Symbol(b, Decl(iteratorZip.ts, 113, 30)) +>Iterator.zipKeyed(a41).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->m : Symbol(m, Decl(iteratorZip.ts, 114, 13)) +>a41 : Symbol(a41, Decl(iteratorZip.ts, 112, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -declare const o: { a: Iterable; } | { b: number; }; ->o : Symbol(o, Decl(iteratorZip.ts, 116, 13)) ->a : Symbol(a, Decl(iteratorZip.ts, 116, 18)) +declare const a43: { a: Iterable; } | { b: number; }; +>a43 : Symbol(a43, Decl(iteratorZip.ts, 114, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 114, 20)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->b : Symbol(b, Decl(iteratorZip.ts, 116, 45)) +>b : Symbol(b, Decl(iteratorZip.ts, 114, 47)) -Iterator.zipKeyed(o); +Iterator.zipKeyed(a43); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->o : Symbol(o, Decl(iteratorZip.ts, 116, 13)) +>a43 : Symbol(a43, Decl(iteratorZip.ts, 114, 13)) -Iterator.zipKeyed(o, { mode: "longest" }); +Iterator.zipKeyed(a43, { mode: "longest" }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->o : Symbol(o, Decl(iteratorZip.ts, 116, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 118, 22)) +>a43 : Symbol(a43, Decl(iteratorZip.ts, 114, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 116, 24)) -Iterator.zipKeyed(o, { mode: "longest", padding: {} }); +Iterator.zipKeyed(a43, { mode: "longest", padding: {} }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->o : Symbol(o, Decl(iteratorZip.ts, 116, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 119, 22)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 119, 39)) +>a43 : Symbol(a43, Decl(iteratorZip.ts, 114, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 117, 24)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 117, 41)) -declare const p: { a?: Iterable; } | { b: string; }; ->p : Symbol(p, Decl(iteratorZip.ts, 120, 13)) ->a : Symbol(a, Decl(iteratorZip.ts, 120, 18)) +declare const a44: { a?: Iterable; } | { b: string; }; +>a44 : Symbol(a44, Decl(iteratorZip.ts, 118, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 118, 20)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->b : Symbol(b, Decl(iteratorZip.ts, 120, 46)) +>b : Symbol(b, Decl(iteratorZip.ts, 118, 48)) -Iterator.zipKeyed(p); +Iterator.zipKeyed(a44); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->p : Symbol(p, Decl(iteratorZip.ts, 120, 13)) +>a44 : Symbol(a44, Decl(iteratorZip.ts, 118, 13)) -declare const q: { a: Iterable; } | { b: undefined; }; ->q : Symbol(q, Decl(iteratorZip.ts, 122, 13)) ->a : Symbol(a, Decl(iteratorZip.ts, 122, 18)) +declare const a45: { a: Iterable; } | { b: undefined; }; +>a45 : Symbol(a45, Decl(iteratorZip.ts, 120, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 120, 20)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->b : Symbol(b, Decl(iteratorZip.ts, 122, 45)) +>b : Symbol(b, Decl(iteratorZip.ts, 120, 47)) -const r: { a: number; }[] = Iterator.zipKeyed(q).toArray(); ->r : Symbol(r, Decl(iteratorZip.ts, 123, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 123, 10)) ->Iterator.zipKeyed(q).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a46: { a: number; }[] = Iterator.zipKeyed(a45).toArray(); +>a46 : Symbol(a46, Decl(iteratorZip.ts, 121, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 121, 12)) +>Iterator.zipKeyed(a45).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->q : Symbol(q, Decl(iteratorZip.ts, 122, 13)) +>a45 : Symbol(a45, Decl(iteratorZip.ts, 120, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -declare const s: unique symbol; ->s : Symbol(s, Decl(iteratorZip.ts, 125, 13)) +declare const a47: unique symbol; +>a47 : Symbol(a47, Decl(iteratorZip.ts, 123, 13)) -declare const t: { a: Iterable; [s]?: Iterable; }; ->t : Symbol(t, Decl(iteratorZip.ts, 126, 13)) ->a : Symbol(a, Decl(iteratorZip.ts, 126, 18)) +declare const a48: { a: Iterable; [a47]?: Iterable; }; +>a48 : Symbol(a48, Decl(iteratorZip.ts, 124, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 124, 20)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->[s] : Symbol([s], Decl(iteratorZip.ts, 126, 39)) ->s : Symbol(s, Decl(iteratorZip.ts, 125, 13)) +>[a47] : Symbol([a47], Decl(iteratorZip.ts, 124, 41)) +>a47 : Symbol(a47, Decl(iteratorZip.ts, 123, 13)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) -const u: { a: number; [s]?: string; }[] = Iterator.zipKeyed(t).toArray(); ->u : Symbol(u, Decl(iteratorZip.ts, 127, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 127, 10)) ->[s] : Symbol([s], Decl(iteratorZip.ts, 127, 21)) ->s : Symbol(s, Decl(iteratorZip.ts, 125, 13)) ->Iterator.zipKeyed(t).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a49: { a: number; [a47]?: string; }[] = Iterator.zipKeyed(a48).toArray(); +>a49 : Symbol(a49, Decl(iteratorZip.ts, 125, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 125, 12)) +>[a47] : Symbol([a47], Decl(iteratorZip.ts, 125, 23)) +>a47 : Symbol(a47, Decl(iteratorZip.ts, 123, 13)) +>Iterator.zipKeyed(a48).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->t : Symbol(t, Decl(iteratorZip.ts, 126, 13)) +>a48 : Symbol(a48, Decl(iteratorZip.ts, 124, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) Iterator.zipKeyed({ a: [1], b: null }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 129, 19)) ->b : Symbol(b, Decl(iteratorZip.ts, 129, 27)) +>a : Symbol(a, Decl(iteratorZip.ts, 127, 19)) +>b : Symbol(b, Decl(iteratorZip.ts, 127, 27)) Iterator.zipKeyed({ a: [1], b: false }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 130, 19)) ->b : Symbol(b, Decl(iteratorZip.ts, 130, 27)) +>a : Symbol(a, Decl(iteratorZip.ts, 128, 19)) +>b : Symbol(b, Decl(iteratorZip.ts, 128, 27)) Iterator.zip([undefined]); >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) @@ -672,658 +674,725 @@ Iterator.zip([undefined]); >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >undefined : Symbol(undefined) -declare const v: { a?: undefined; }; ->v : Symbol(v, Decl(iteratorZip.ts, 133, 13)) ->a : Symbol(a, Decl(iteratorZip.ts, 133, 18)) +declare const a50: { a?: undefined; }; +>a50 : Symbol(a50, Decl(iteratorZip.ts, 131, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 131, 20)) -const w: never[] = Iterator.zipKeyed(v).toArray(); ->w : Symbol(w, Decl(iteratorZip.ts, 134, 5)) ->Iterator.zipKeyed(v).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a51: never[] = Iterator.zipKeyed(a50).toArray(); +>a51 : Symbol(a51, Decl(iteratorZip.ts, 132, 5)) +>Iterator.zipKeyed(a50).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->v : Symbol(v, Decl(iteratorZip.ts, 133, 13)) +>a50 : Symbol(a50, Decl(iteratorZip.ts, 131, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const x: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); ->x : Symbol(x, Decl(iteratorZip.ts, 135, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 135, 10)) +const a52: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); +>a52 : Symbol(a52, Decl(iteratorZip.ts, 133, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 133, 12)) >Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 135, 47)) ->b : Symbol(b, Decl(iteratorZip.ts, 135, 55)) +>a : Symbol(a, Decl(iteratorZip.ts, 133, 49)) +>b : Symbol(b, Decl(iteratorZip.ts, 133, 57)) >undefined : Symbol(undefined) ->mode : Symbol(mode, Decl(iteratorZip.ts, 135, 73)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 135, 90)) ->a : Symbol(a, Decl(iteratorZip.ts, 135, 101)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 133, 75)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 133, 92)) +>a : Symbol(a, Decl(iteratorZip.ts, 133, 103)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const y: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); ->y : Symbol(y, Decl(iteratorZip.ts, 136, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 136, 10)) +const a53: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); +>a53 : Symbol(a53, Decl(iteratorZip.ts, 134, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 134, 12)) >Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 136, 59)) ->b : Symbol(b, Decl(iteratorZip.ts, 136, 67)) +>a : Symbol(a, Decl(iteratorZip.ts, 134, 61)) +>b : Symbol(b, Decl(iteratorZip.ts, 134, 69)) >undefined : Symbol(undefined) ->mode : Symbol(mode, Decl(iteratorZip.ts, 136, 85)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 134, 87)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) function f1(a: Iterable) { ->f1 : Symbol(f1, Decl(iteratorZip.ts, 136, 115)) ->T : Symbol(T, Decl(iteratorZip.ts, 138, 12)) ->a : Symbol(a, Decl(iteratorZip.ts, 138, 15)) +>f1 : Symbol(f1, Decl(iteratorZip.ts, 134, 117)) +>T : Symbol(T, Decl(iteratorZip.ts, 136, 12)) +>a : Symbol(a, Decl(iteratorZip.ts, 136, 15)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->T : Symbol(T, Decl(iteratorZip.ts, 138, 12)) +>T : Symbol(T, Decl(iteratorZip.ts, 136, 12)) const b: { a: T; }[] = Iterator.zipKeyed({ a }).toArray(); ->b : Symbol(b, Decl(iteratorZip.ts, 139, 9)) ->a : Symbol(a, Decl(iteratorZip.ts, 139, 14)) ->T : Symbol(T, Decl(iteratorZip.ts, 138, 12)) +>b : Symbol(b, Decl(iteratorZip.ts, 137, 9)) +>a : Symbol(a, Decl(iteratorZip.ts, 137, 14)) +>T : Symbol(T, Decl(iteratorZip.ts, 136, 12)) >Iterator.zipKeyed({ a }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 139, 46)) +>a : Symbol(a, Decl(iteratorZip.ts, 137, 46)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const c: [T][] = Iterator.zip([a]).toArray(); ->c : Symbol(c, Decl(iteratorZip.ts, 140, 9)) ->T : Symbol(T, Decl(iteratorZip.ts, 138, 12)) +>c : Symbol(c, Decl(iteratorZip.ts, 138, 9)) +>T : Symbol(T, Decl(iteratorZip.ts, 136, 12)) >Iterator.zip([a]).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->a : Symbol(a, Decl(iteratorZip.ts, 138, 15)) +>a : Symbol(a, Decl(iteratorZip.ts, 136, 15)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) return { b, c }; ->b : Symbol(b, Decl(iteratorZip.ts, 141, 12)) ->c : Symbol(c, Decl(iteratorZip.ts, 141, 15)) +>b : Symbol(b, Decl(iteratorZip.ts, 139, 12)) +>c : Symbol(c, Decl(iteratorZip.ts, 139, 15)) } -// Padding - -const paddingA: [Iterable, ...Iterable[]] = [[1, 2], [3]]; ->paddingA : Symbol(paddingA, Decl(iteratorZip.ts, 146, 5)) +const a54: [Iterable, ...Iterable[]] = [[1, 2], [3]]; +>a54 : Symbol(a54, Decl(iteratorZip.ts, 142, 5)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) -const paddingB = Iterator.zip(paddingA, { mode: "longest", padding: [0] }).toArray(); ->paddingB : Symbol(paddingB, Decl(iteratorZip.ts, 147, 5)) ->Iterator.zip(paddingA, { mode: "longest", padding: [0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a55 = Iterator.zip(a54, { mode: "longest", padding: [0] }).toArray(); +>a55 : Symbol(a55, Decl(iteratorZip.ts, 143, 5)) +>Iterator.zip(a54, { mode: "longest", padding: [0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->paddingA : Symbol(paddingA, Decl(iteratorZip.ts, 146, 5)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 147, 41)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 147, 58)) +>a54 : Symbol(a54, Decl(iteratorZip.ts, 142, 5)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 143, 31)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 143, 48)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const paddingC: (number | undefined)[][] = paddingB; ->paddingC : Symbol(paddingC, Decl(iteratorZip.ts, 148, 5)) ->paddingB : Symbol(paddingB, Decl(iteratorZip.ts, 147, 5)) +const a56: (number | undefined)[][] = a55; +>a56 : Symbol(a56, Decl(iteratorZip.ts, 144, 5)) +>a55 : Symbol(a55, Decl(iteratorZip.ts, 143, 5)) -const paddingD: number[][] = paddingB; ->paddingD : Symbol(paddingD, Decl(iteratorZip.ts, 149, 5)) ->paddingB : Symbol(paddingB, Decl(iteratorZip.ts, 147, 5)) +const a57: number[][] = a55; +>a57 : Symbol(a57, Decl(iteratorZip.ts, 145, 5)) +>a55 : Symbol(a55, Decl(iteratorZip.ts, 143, 5)) -const paddingE: Record> = { a: [1], b: [2, 3] }; ->paddingE : Symbol(paddingE, Decl(iteratorZip.ts, 151, 5)) +const a58: Record> = { a: [1], b: [2, 3] }; +>a58 : Symbol(a58, Decl(iteratorZip.ts, 147, 5)) >Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 151, 52)) ->b : Symbol(b, Decl(iteratorZip.ts, 151, 60)) +>a : Symbol(a, Decl(iteratorZip.ts, 147, 47)) +>b : Symbol(b, Decl(iteratorZip.ts, 147, 55)) -const paddingF = Iterator.zipKeyed(paddingE, { mode: "longest", padding: {} }).toArray(); ->paddingF : Symbol(paddingF, Decl(iteratorZip.ts, 152, 5)) ->Iterator.zipKeyed(paddingE, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a59 = Iterator.zipKeyed(a58, { mode: "longest", padding: {} }).toArray(); +>a59 : Symbol(a59, Decl(iteratorZip.ts, 148, 5)) +>Iterator.zipKeyed(a58, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->paddingE : Symbol(paddingE, Decl(iteratorZip.ts, 151, 5)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 152, 46)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 152, 63)) +>a58 : Symbol(a58, Decl(iteratorZip.ts, 147, 5)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 148, 36)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 148, 53)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const paddingG: Record[] = paddingF; ->paddingG : Symbol(paddingG, Decl(iteratorZip.ts, 153, 5)) +const a60: Record[] = a59; +>a60 : Symbol(a60, Decl(iteratorZip.ts, 149, 5)) >Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) ->paddingF : Symbol(paddingF, Decl(iteratorZip.ts, 152, 5)) +>a59 : Symbol(a59, Decl(iteratorZip.ts, 148, 5)) -const paddingH: Record[] = paddingF; ->paddingH : Symbol(paddingH, Decl(iteratorZip.ts, 154, 5)) +const a61: Record[] = a59; +>a61 : Symbol(a61, Decl(iteratorZip.ts, 150, 5)) >Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) ->paddingF : Symbol(paddingF, Decl(iteratorZip.ts, 152, 5)) +>a59 : Symbol(a59, Decl(iteratorZip.ts, 148, 5)) -declare const paddingI: Record; ->paddingI : Symbol(paddingI, Decl(iteratorZip.ts, 156, 13)) +declare const a62: Record; +>a62 : Symbol(a62, Decl(iteratorZip.ts, 152, 13)) >Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) -const paddingJ = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: paddingI }).toArray(); ->paddingJ : Symbol(paddingJ, Decl(iteratorZip.ts, 157, 5)) ->Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: paddingI }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a63 = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a62 }).toArray(); +>a63 : Symbol(a63, Decl(iteratorZip.ts, 153, 5)) +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a62 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 157, 36)) ->b : Symbol(b, Decl(iteratorZip.ts, 157, 44)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 157, 59)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 157, 76)) ->paddingI : Symbol(paddingI, Decl(iteratorZip.ts, 156, 13)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const paddingK: { a: number | undefined; b: number | undefined; }[] = paddingJ; ->paddingK : Symbol(paddingK, Decl(iteratorZip.ts, 158, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 158, 17)) ->b : Symbol(b, Decl(iteratorZip.ts, 158, 40)) ->paddingJ : Symbol(paddingJ, Decl(iteratorZip.ts, 157, 5)) - -const paddingL: { a: number; b: number; }[] = paddingJ; ->paddingL : Symbol(paddingL, Decl(iteratorZip.ts, 159, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 159, 17)) ->b : Symbol(b, Decl(iteratorZip.ts, 159, 28)) ->paddingJ : Symbol(paddingJ, Decl(iteratorZip.ts, 157, 5)) - -const paddingM = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); ->paddingM : Symbol(paddingM, Decl(iteratorZip.ts, 161, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 153, 31)) +>b : Symbol(b, Decl(iteratorZip.ts, 153, 39)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 153, 54)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 153, 71)) +>a62 : Symbol(a62, Decl(iteratorZip.ts, 152, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a64: { a: number | undefined; b: number | undefined; }[] = a63; +>a64 : Symbol(a64, Decl(iteratorZip.ts, 154, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 154, 12)) +>b : Symbol(b, Decl(iteratorZip.ts, 154, 35)) +>a63 : Symbol(a63, Decl(iteratorZip.ts, 153, 5)) + +const a65: { a: number; b: number; }[] = a63; +>a65 : Symbol(a65, Decl(iteratorZip.ts, 155, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 155, 12)) +>b : Symbol(b, Decl(iteratorZip.ts, 155, 23)) +>a63 : Symbol(a63, Decl(iteratorZip.ts, 153, 5)) + +const a66 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); +>a66 : Symbol(a66, Decl(iteratorZip.ts, 157, 5)) >Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 161, 45)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 161, 62)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 157, 40)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 157, 57)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const paddingN: [number, string][] = paddingM; ->paddingN : Symbol(paddingN, Decl(iteratorZip.ts, 162, 5)) ->paddingM : Symbol(paddingM, Decl(iteratorZip.ts, 161, 5)) +const a67: [number, string][] = a66; +>a67 : Symbol(a67, Decl(iteratorZip.ts, 158, 5)) +>a66 : Symbol(a66, Decl(iteratorZip.ts, 157, 5)) -const paddingO = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); ->paddingO : Symbol(paddingO, Decl(iteratorZip.ts, 163, 5)) +const a68 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); +>a68 : Symbol(a68, Decl(iteratorZip.ts, 159, 5)) >Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 163, 36)) ->b : Symbol(b, Decl(iteratorZip.ts, 163, 44)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 163, 58)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 163, 75)) ->a : Symbol(a, Decl(iteratorZip.ts, 163, 86)) ->b : Symbol(b, Decl(iteratorZip.ts, 163, 92)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const paddingP: { a: number; b: string; }[] = paddingO; ->paddingP : Symbol(paddingP, Decl(iteratorZip.ts, 164, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 164, 17)) ->b : Symbol(b, Decl(iteratorZip.ts, 164, 28)) ->paddingO : Symbol(paddingO, Decl(iteratorZip.ts, 163, 5)) - -const paddingQ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); ->paddingQ : Symbol(paddingQ, Decl(iteratorZip.ts, 166, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 159, 31)) +>b : Symbol(b, Decl(iteratorZip.ts, 159, 39)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 159, 53)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 159, 70)) +>a : Symbol(a, Decl(iteratorZip.ts, 159, 81)) +>b : Symbol(b, Decl(iteratorZip.ts, 159, 87)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a69: { a: number; b: string; }[] = a68; +>a69 : Symbol(a69, Decl(iteratorZip.ts, 160, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 160, 12)) +>b : Symbol(b, Decl(iteratorZip.ts, 160, 23)) +>a68 : Symbol(a68, Decl(iteratorZip.ts, 159, 5)) + +const a70 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); +>a70 : Symbol(a70, Decl(iteratorZip.ts, 162, 5)) >Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 166, 45)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 166, 62)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 162, 40)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 162, 57)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const paddingR: [number | undefined, string | undefined][] = paddingQ; ->paddingR : Symbol(paddingR, Decl(iteratorZip.ts, 167, 5)) ->paddingQ : Symbol(paddingQ, Decl(iteratorZip.ts, 166, 5)) +const a71: [number | undefined, string | undefined][] = a70; +>a71 : Symbol(a71, Decl(iteratorZip.ts, 163, 5)) +>a70 : Symbol(a70, Decl(iteratorZip.ts, 162, 5)) -const paddingS: [number, string][] = paddingQ; ->paddingS : Symbol(paddingS, Decl(iteratorZip.ts, 168, 5)) ->paddingQ : Symbol(paddingQ, Decl(iteratorZip.ts, 166, 5)) +const a72: [number, string][] = a70; +>a72 : Symbol(a72, Decl(iteratorZip.ts, 164, 5)) +>a70 : Symbol(a70, Decl(iteratorZip.ts, 162, 5)) -const paddingT = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); ->paddingT : Symbol(paddingT, Decl(iteratorZip.ts, 169, 5)) +const a73 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); +>a73 : Symbol(a73, Decl(iteratorZip.ts, 165, 5)) >Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 169, 36)) ->b : Symbol(b, Decl(iteratorZip.ts, 169, 44)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 169, 58)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 169, 75)) ->a : Symbol(a, Decl(iteratorZip.ts, 169, 86)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const paddingU: { a: number | undefined; b: string | undefined; }[] = paddingT; ->paddingU : Symbol(paddingU, Decl(iteratorZip.ts, 170, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 170, 17)) ->b : Symbol(b, Decl(iteratorZip.ts, 170, 40)) ->paddingT : Symbol(paddingT, Decl(iteratorZip.ts, 169, 5)) - -const paddingV: { a: number; b: string; }[] = paddingT; ->paddingV : Symbol(paddingV, Decl(iteratorZip.ts, 171, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 171, 17)) ->b : Symbol(b, Decl(iteratorZip.ts, 171, 28)) ->paddingT : Symbol(paddingT, Decl(iteratorZip.ts, 169, 5)) - -declare const paddingW: readonly [number, string]; ->paddingW : Symbol(paddingW, Decl(iteratorZip.ts, 173, 13)) - -const paddingX: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingW }).toArray(); ->paddingX : Symbol(paddingX, Decl(iteratorZip.ts, 174, 5)) ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingW }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 165, 31)) +>b : Symbol(b, Decl(iteratorZip.ts, 165, 39)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 165, 53)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 165, 70)) +>a : Symbol(a, Decl(iteratorZip.ts, 165, 81)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a74: { a: number | undefined; b: string | undefined; }[] = a73; +>a74 : Symbol(a74, Decl(iteratorZip.ts, 166, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 166, 12)) +>b : Symbol(b, Decl(iteratorZip.ts, 166, 35)) +>a73 : Symbol(a73, Decl(iteratorZip.ts, 165, 5)) + +const a75: { a: number; b: string; }[] = a73; +>a75 : Symbol(a75, Decl(iteratorZip.ts, 167, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 167, 12)) +>b : Symbol(b, Decl(iteratorZip.ts, 167, 23)) +>a73 : Symbol(a73, Decl(iteratorZip.ts, 165, 5)) + +declare const a76: readonly [number, string]; +>a76 : Symbol(a76, Decl(iteratorZip.ts, 169, 13)) + +const a77: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a76 }).toArray(); +>a77 : Symbol(a77, Decl(iteratorZip.ts, 170, 5)) +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: a76 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 174, 65)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 174, 82)) ->paddingW : Symbol(paddingW, Decl(iteratorZip.ts, 173, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 170, 60)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 170, 77)) +>a76 : Symbol(a76, Decl(iteratorZip.ts, 169, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -declare const paddingY: [number, string?]; ->paddingY : Symbol(paddingY, Decl(iteratorZip.ts, 175, 13)) +declare const a78: [number, string?]; +>a78 : Symbol(a78, Decl(iteratorZip.ts, 171, 13)) -const paddingZ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY }).toArray(); ->paddingZ : Symbol(paddingZ, Decl(iteratorZip.ts, 176, 5)) ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a79 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a78 }).toArray(); +>a79 : Symbol(a79, Decl(iteratorZip.ts, 172, 5)) +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: a78 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 176, 45)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 176, 62)) ->paddingY : Symbol(paddingY, Decl(iteratorZip.ts, 175, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 172, 40)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 172, 57)) +>a78 : Symbol(a78, Decl(iteratorZip.ts, 171, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const paddingA1: [number, string][] = paddingZ; ->paddingA1 : Symbol(paddingA1, Decl(iteratorZip.ts, 177, 5)) ->paddingZ : Symbol(paddingZ, Decl(iteratorZip.ts, 176, 5)) +const a80: [number, string][] = a79; +>a80 : Symbol(a80, Decl(iteratorZip.ts, 173, 5)) +>a79 : Symbol(a79, Decl(iteratorZip.ts, 172, 5)) -declare const paddingB1: [Iterable] | [Iterable, Iterable]; ->paddingB1 : Symbol(paddingB1, Decl(iteratorZip.ts, 179, 13)) +declare const a81: [Iterable] | [Iterable, Iterable]; +>a81 : Symbol(a81, Decl(iteratorZip.ts, 175, 13)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) -const paddingC1 = Iterator.zip(paddingB1, { mode: "longest", padding: [0] }).toArray(); ->paddingC1 : Symbol(paddingC1, Decl(iteratorZip.ts, 180, 5)) ->Iterator.zip(paddingB1, { mode: "longest", padding: [0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a82 = Iterator.zip(a81, { mode: "longest", padding: [0] }).toArray(); +>a82 : Symbol(a82, Decl(iteratorZip.ts, 176, 5)) +>Iterator.zip(a81, { mode: "longest", padding: [0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->paddingB1 : Symbol(paddingB1, Decl(iteratorZip.ts, 179, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 180, 43)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 180, 60)) +>a81 : Symbol(a81, Decl(iteratorZip.ts, 175, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 176, 31)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 176, 48)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const paddingD1: number[][] = paddingC1; ->paddingD1 : Symbol(paddingD1, Decl(iteratorZip.ts, 181, 5)) ->paddingC1 : Symbol(paddingC1, Decl(iteratorZip.ts, 180, 5)) +const a83: number[][] = a82; +>a83 : Symbol(a83, Decl(iteratorZip.ts, 177, 5)) +>a82 : Symbol(a82, Decl(iteratorZip.ts, 176, 5)) -declare const paddingE1: { a: Iterable; } | { b: Iterable; }; ->paddingE1 : Symbol(paddingE1, Decl(iteratorZip.ts, 182, 13)) ->a : Symbol(a, Decl(iteratorZip.ts, 182, 26)) +declare const a84: { a: Iterable; } | { b: Iterable; }; +>a84 : Symbol(a84, Decl(iteratorZip.ts, 178, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 178, 20)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->b : Symbol(b, Decl(iteratorZip.ts, 182, 53)) +>b : Symbol(b, Decl(iteratorZip.ts, 178, 47)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) -const paddingF1 = Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: 0 } }).toArray(); ->paddingF1 : Symbol(paddingF1, Decl(iteratorZip.ts, 183, 5)) ->Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a85 = Iterator.zipKeyed(a84, { mode: "longest", padding: { a: 0 } }).toArray(); +>a85 : Symbol(a85, Decl(iteratorZip.ts, 179, 5)) +>Iterator.zipKeyed(a84, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->paddingE1 : Symbol(paddingE1, Decl(iteratorZip.ts, 182, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 183, 48)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 183, 65)) ->a : Symbol(a, Decl(iteratorZip.ts, 183, 76)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const paddingG1: ({ a: number; } | { b: string; })[] = paddingF1; ->paddingG1 : Symbol(paddingG1, Decl(iteratorZip.ts, 184, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 184, 19)) ->b : Symbol(b, Decl(iteratorZip.ts, 184, 36)) ->paddingF1 : Symbol(paddingF1, Decl(iteratorZip.ts, 183, 5)) - -declare const paddingH1: { a: number; } | { b: string; }; ->paddingH1 : Symbol(paddingH1, Decl(iteratorZip.ts, 186, 13)) ->a : Symbol(a, Decl(iteratorZip.ts, 186, 26)) ->b : Symbol(b, Decl(iteratorZip.ts, 186, 43)) - -const paddingI1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: paddingH1 }).toArray(); ->paddingI1 : Symbol(paddingI1, Decl(iteratorZip.ts, 187, 5)) ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: paddingH1 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>a84 : Symbol(a84, Decl(iteratorZip.ts, 178, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 179, 36)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 179, 53)) +>a : Symbol(a, Decl(iteratorZip.ts, 179, 64)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a86: ({ a: number; } | { b: string; })[] = a85; +>a86 : Symbol(a86, Decl(iteratorZip.ts, 180, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 180, 13)) +>b : Symbol(b, Decl(iteratorZip.ts, 180, 30)) +>a85 : Symbol(a85, Decl(iteratorZip.ts, 179, 5)) + +declare const a87: { a: number; } | { b: string; }; +>a87 : Symbol(a87, Decl(iteratorZip.ts, 182, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 182, 20)) +>b : Symbol(b, Decl(iteratorZip.ts, 182, 37)) + +const a88 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: a87 }).toArray(); +>a88 : Symbol(a88, Decl(iteratorZip.ts, 183, 5)) +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: a87 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 187, 37)) ->b : Symbol(b, Decl(iteratorZip.ts, 187, 45)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 187, 59)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 187, 76)) ->paddingH1 : Symbol(paddingH1, Decl(iteratorZip.ts, 186, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 183, 31)) +>b : Symbol(b, Decl(iteratorZip.ts, 183, 39)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 183, 53)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 183, 70)) +>a87 : Symbol(a87, Decl(iteratorZip.ts, 182, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const paddingJ1: { a: number; b: string; }[] = paddingI1; ->paddingJ1 : Symbol(paddingJ1, Decl(iteratorZip.ts, 188, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 188, 18)) ->b : Symbol(b, Decl(iteratorZip.ts, 188, 29)) ->paddingI1 : Symbol(paddingI1, Decl(iteratorZip.ts, 187, 5)) +const a89: { a: number; b: string; }[] = a88; +>a89 : Symbol(a89, Decl(iteratorZip.ts, 184, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 184, 12)) +>b : Symbol(b, Decl(iteratorZip.ts, 184, 23)) +>a88 : Symbol(a88, Decl(iteratorZip.ts, 183, 5)) -const paddingK1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); ->paddingK1 : Symbol(paddingK1, Decl(iteratorZip.ts, 190, 5)) +const a90 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); +>a90 : Symbol(a90, Decl(iteratorZip.ts, 186, 5)) >Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 190, 37)) ->b : Symbol(b, Decl(iteratorZip.ts, 190, 45)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 190, 57)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 190, 74)) ->a : Symbol(a, Decl(iteratorZip.ts, 190, 85)) +>a : Symbol(a, Decl(iteratorZip.ts, 186, 31)) +>b : Symbol(b, Decl(iteratorZip.ts, 186, 39)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 186, 51)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 186, 68)) +>a : Symbol(a, Decl(iteratorZip.ts, 186, 79)) >undefined : Symbol(undefined) ->b : Symbol(b, Decl(iteratorZip.ts, 190, 99)) +>b : Symbol(b, Decl(iteratorZip.ts, 186, 93)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const paddingL1: { a: number; b: number; }[] = paddingK1; ->paddingL1 : Symbol(paddingL1, Decl(iteratorZip.ts, 191, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 191, 18)) ->b : Symbol(b, Decl(iteratorZip.ts, 191, 29)) ->paddingK1 : Symbol(paddingK1, Decl(iteratorZip.ts, 190, 5)) +const a91: { a: number; b: number; }[] = a90; +>a91 : Symbol(a91, Decl(iteratorZip.ts, 187, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 187, 12)) +>b : Symbol(b, Decl(iteratorZip.ts, 187, 23)) +>a90 : Symbol(a90, Decl(iteratorZip.ts, 186, 5)) -declare const paddingM1: { [K in `a${string}`]: Iterable; }; ->paddingM1 : Symbol(paddingM1, Decl(iteratorZip.ts, 193, 13)) ->K : Symbol(K, Decl(iteratorZip.ts, 193, 28)) +declare const a92: { [K in `a${string}`]: Iterable; }; +>a92 : Symbol(a92, Decl(iteratorZip.ts, 189, 13)) +>K : Symbol(K, Decl(iteratorZip.ts, 189, 22)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) -const paddingN1 = Iterator.zipKeyed(paddingM1, { mode: "longest", padding: {} }).toArray(); ->paddingN1 : Symbol(paddingN1, Decl(iteratorZip.ts, 194, 5)) ->Iterator.zipKeyed(paddingM1, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a93 = Iterator.zipKeyed(a92, { mode: "longest", padding: {} }).toArray(); +>a93 : Symbol(a93, Decl(iteratorZip.ts, 190, 5)) +>Iterator.zipKeyed(a92, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->paddingM1 : Symbol(paddingM1, Decl(iteratorZip.ts, 193, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 194, 48)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 194, 65)) +>a92 : Symbol(a92, Decl(iteratorZip.ts, 189, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 190, 36)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 190, 53)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const paddingO1: { [K in `a${string}`]: number; }[] = paddingN1; ->paddingO1 : Symbol(paddingO1, Decl(iteratorZip.ts, 195, 5)) ->K : Symbol(K, Decl(iteratorZip.ts, 195, 20)) ->paddingN1 : Symbol(paddingN1, Decl(iteratorZip.ts, 194, 5)) +const a94: { [K in `a${string}`]: number; }[] = a93; +>a94 : Symbol(a94, Decl(iteratorZip.ts, 191, 5)) +>K : Symbol(K, Decl(iteratorZip.ts, 191, 14)) +>a93 : Symbol(a93, Decl(iteratorZip.ts, 190, 5)) -declare const paddingP1: unique symbol; ->paddingP1 : Symbol(paddingP1, Decl(iteratorZip.ts, 197, 13)) +declare const a95: unique symbol; +>a95 : Symbol(a95, Decl(iteratorZip.ts, 193, 13)) -const paddingQ1: { [paddingP1]: number; }[] = Iterator.zipKeyed({ [paddingP1]: [1] }, { mode: "longest", padding: { [paddingP1]: 0 } }).toArray(); ->paddingQ1 : Symbol(paddingQ1, Decl(iteratorZip.ts, 198, 5)) ->[paddingP1] : Symbol([paddingP1], Decl(iteratorZip.ts, 198, 18)) ->paddingP1 : Symbol(paddingP1, Decl(iteratorZip.ts, 197, 13)) ->Iterator.zipKeyed({ [paddingP1]: [1] }, { mode: "longest", padding: { [paddingP1]: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a96: { [a95]: number; }[] = Iterator.zipKeyed({ [a95]: [1] }, { mode: "longest", padding: { [a95]: 0 } }).toArray(); +>a96 : Symbol(a96, Decl(iteratorZip.ts, 194, 5)) +>[a95] : Symbol([a95], Decl(iteratorZip.ts, 194, 12)) +>a95 : Symbol(a95, Decl(iteratorZip.ts, 193, 13)) +>Iterator.zipKeyed({ [a95]: [1] }, { mode: "longest", padding: { [a95]: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->[paddingP1] : Symbol([paddingP1], Decl(iteratorZip.ts, 198, 65)) ->paddingP1 : Symbol(paddingP1, Decl(iteratorZip.ts, 197, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 198, 87)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 198, 104)) ->[paddingP1] : Symbol([paddingP1], Decl(iteratorZip.ts, 198, 115)) ->paddingP1 : Symbol(paddingP1, Decl(iteratorZip.ts, 197, 13)) +>[a95] : Symbol([a95], Decl(iteratorZip.ts, 194, 53)) +>a95 : Symbol(a95, Decl(iteratorZip.ts, 193, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 194, 69)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 194, 86)) +>[a95] : Symbol([a95], Decl(iteratorZip.ts, 194, 97)) +>a95 : Symbol(a95, Decl(iteratorZip.ts, 193, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -declare const paddingR1: Record & { a: number; }; ->paddingR1 : Symbol(paddingR1, Decl(iteratorZip.ts, 200, 13)) +declare const a97: Record & { a: number; }; +>a97 : Symbol(a97, Decl(iteratorZip.ts, 196, 13)) >Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 200, 51)) +>a : Symbol(a, Decl(iteratorZip.ts, 196, 45)) -const paddingS1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: paddingR1 }).toArray(); ->paddingS1 : Symbol(paddingS1, Decl(iteratorZip.ts, 201, 5)) ->Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: paddingR1 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a98 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: a97 }).toArray(); +>a98 : Symbol(a98, Decl(iteratorZip.ts, 197, 5)) +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: a97 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 201, 37)) ->b : Symbol(b, Decl(iteratorZip.ts, 201, 45)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 201, 57)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 201, 74)) ->paddingR1 : Symbol(paddingR1, Decl(iteratorZip.ts, 200, 13)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const paddingT1: { a: number; b: number | undefined; }[] = paddingS1; ->paddingT1 : Symbol(paddingT1, Decl(iteratorZip.ts, 202, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 202, 18)) ->b : Symbol(b, Decl(iteratorZip.ts, 202, 29)) ->paddingS1 : Symbol(paddingS1, Decl(iteratorZip.ts, 201, 5)) - -const paddingU1: { a: number; b: number; }[] = paddingS1; ->paddingU1 : Symbol(paddingU1, Decl(iteratorZip.ts, 203, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 203, 18)) ->b : Symbol(b, Decl(iteratorZip.ts, 203, 29)) ->paddingS1 : Symbol(paddingS1, Decl(iteratorZip.ts, 201, 5)) - -declare const paddingV1: [number] | [number, string]; ->paddingV1 : Symbol(paddingV1, Decl(iteratorZip.ts, 205, 13)) - -const paddingW1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingV1 }).toArray(); ->paddingW1 : Symbol(paddingW1, Decl(iteratorZip.ts, 206, 5)) ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingV1 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 197, 31)) +>b : Symbol(b, Decl(iteratorZip.ts, 197, 39)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 197, 51)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 197, 68)) +>a97 : Symbol(a97, Decl(iteratorZip.ts, 196, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a99: { a: number; b: number | undefined; }[] = a98; +>a99 : Symbol(a99, Decl(iteratorZip.ts, 198, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 198, 12)) +>b : Symbol(b, Decl(iteratorZip.ts, 198, 23)) +>a98 : Symbol(a98, Decl(iteratorZip.ts, 197, 5)) + +const a100: { a: number; b: number; }[] = a98; +>a100 : Symbol(a100, Decl(iteratorZip.ts, 199, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 199, 13)) +>b : Symbol(b, Decl(iteratorZip.ts, 199, 24)) +>a98 : Symbol(a98, Decl(iteratorZip.ts, 197, 5)) + +declare const a101: [number] | [number, string]; +>a101 : Symbol(a101, Decl(iteratorZip.ts, 201, 13)) + +const a102 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a101 }).toArray(); +>a102 : Symbol(a102, Decl(iteratorZip.ts, 202, 5)) +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: a101 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 206, 46)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 206, 63)) ->paddingV1 : Symbol(paddingV1, Decl(iteratorZip.ts, 205, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 202, 41)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 202, 58)) +>a101 : Symbol(a101, Decl(iteratorZip.ts, 201, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const paddingX1: [number, string | undefined][] = paddingW1; ->paddingX1 : Symbol(paddingX1, Decl(iteratorZip.ts, 207, 5)) ->paddingW1 : Symbol(paddingW1, Decl(iteratorZip.ts, 206, 5)) +const a103: [number, string | undefined][] = a102; +>a103 : Symbol(a103, Decl(iteratorZip.ts, 203, 5)) +>a102 : Symbol(a102, Decl(iteratorZip.ts, 202, 5)) -const paddingY1: [number, string][] = paddingW1; ->paddingY1 : Symbol(paddingY1, Decl(iteratorZip.ts, 208, 5)) ->paddingW1 : Symbol(paddingW1, Decl(iteratorZip.ts, 206, 5)) +const a104: [number, string][] = a102; +>a104 : Symbol(a104, Decl(iteratorZip.ts, 204, 5)) +>a102 : Symbol(a102, Decl(iteratorZip.ts, 202, 5)) -const paddingZ1: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); ->paddingZ1 : Symbol(paddingZ1, Decl(iteratorZip.ts, 210, 5)) +const a105: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); +>a105 : Symbol(a105, Decl(iteratorZip.ts, 206, 5)) >Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 210, 76)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 210, 93)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 206, 71)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 206, 88)) >undefined : Symbol(undefined) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const paddingA2: { a: number | undefined; b: number; }[] = paddingK1; ->paddingA2 : Symbol(paddingA2, Decl(iteratorZip.ts, 211, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 211, 18)) ->b : Symbol(b, Decl(iteratorZip.ts, 211, 41)) ->paddingK1 : Symbol(paddingK1, Decl(iteratorZip.ts, 190, 5)) - -// Own properties +const a106: { a: number | undefined; b: number; }[] = a90; +>a106 : Symbol(a106, Decl(iteratorZip.ts, 207, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 207, 13)) +>b : Symbol(b, Decl(iteratorZip.ts, 207, 36)) +>a90 : Symbol(a90, Decl(iteratorZip.ts, 186, 5)) -class InputsWithPrototypeMembers { ->InputsWithPrototypeMembers : Symbol(InputsWithPrototypeMembers, Decl(iteratorZip.ts, 211, 69)) +class C1 { +>C1 : Symbol(C1, Decl(iteratorZip.ts, 207, 58)) - values = [1, 2]; ->values : Symbol(InputsWithPrototypeMembers.values, Decl(iteratorZip.ts, 215, 34)) + a = [1, 2]; +>a : Symbol(C1.a, Decl(iteratorZip.ts, 209, 10)) - get label() { ->label : Symbol(InputsWithPrototypeMembers.label, Decl(iteratorZip.ts, 216, 20)) + get b() { +>b : Symbol(C1.b, Decl(iteratorZip.ts, 210, 15)) return "inputs"; } - describe() { ->describe : Symbol(InputsWithPrototypeMembers.describe, Decl(iteratorZip.ts, 220, 5)) + f() { +>f : Symbol(C1.f, Decl(iteratorZip.ts, 214, 5)) - return this.label; ->this.label : Symbol(InputsWithPrototypeMembers.label, Decl(iteratorZip.ts, 216, 20)) ->this : Symbol(InputsWithPrototypeMembers, Decl(iteratorZip.ts, 211, 69)) ->label : Symbol(InputsWithPrototypeMembers.label, Decl(iteratorZip.ts, 216, 20)) + return this.b; +>this.b : Symbol(C1.b, Decl(iteratorZip.ts, 210, 15)) +>this : Symbol(C1, Decl(iteratorZip.ts, 207, 58)) +>b : Symbol(C1.b, Decl(iteratorZip.ts, 210, 15)) } } -const instance = new InputsWithPrototypeMembers(); ->instance : Symbol(instance, Decl(iteratorZip.ts, 227, 5)) ->InputsWithPrototypeMembers : Symbol(InputsWithPrototypeMembers, Decl(iteratorZip.ts, 211, 69)) +const a107 = new C1(); +>a107 : Symbol(a107, Decl(iteratorZip.ts, 221, 5)) +>C1 : Symbol(C1, Decl(iteratorZip.ts, 207, 58)) -const inherited = Iterator.zipKeyed(instance).toArray(); ->inherited : Symbol(inherited, Decl(iteratorZip.ts, 228, 5)) ->Iterator.zipKeyed(instance).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a108 = Iterator.zipKeyed(a107).toArray(); +>a108 : Symbol(a108, Decl(iteratorZip.ts, 222, 5)) +>Iterator.zipKeyed(a107).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->instance : Symbol(instance, Decl(iteratorZip.ts, 227, 5)) +>a107 : Symbol(a107, Decl(iteratorZip.ts, 221, 5)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const inheritedStrict = Iterator.zipKeyed(instance, { mode: "strict" }).toArray(); ->inheritedStrict : Symbol(inheritedStrict, Decl(iteratorZip.ts, 229, 5)) ->Iterator.zipKeyed(instance, { mode: "strict" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a109 = Iterator.zipKeyed(a107, { mode: "strict" }).toArray(); +>a109 : Symbol(a109, Decl(iteratorZip.ts, 223, 5)) +>Iterator.zipKeyed(a107, { mode: "strict" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->instance : Symbol(instance, Decl(iteratorZip.ts, 227, 5)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 229, 53)) +>a107 : Symbol(a107, Decl(iteratorZip.ts, 221, 5)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 223, 38)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const inheritedLongest = Iterator.zipKeyed(instance, { mode: "longest" }).toArray(); ->inheritedLongest : Symbol(inheritedLongest, Decl(iteratorZip.ts, 230, 5)) ->Iterator.zipKeyed(instance, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a110 = Iterator.zipKeyed(a107, { mode: "longest" }).toArray(); +>a110 : Symbol(a110, Decl(iteratorZip.ts, 224, 5)) +>Iterator.zipKeyed(a107, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->instance : Symbol(instance, Decl(iteratorZip.ts, 227, 5)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 230, 54)) +>a107 : Symbol(a107, Decl(iteratorZip.ts, 221, 5)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 224, 38)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const inheritedPadded = Iterator.zipKeyed(instance, { mode: "longest", padding: { values: 0 } }).toArray(); ->inheritedPadded : Symbol(inheritedPadded, Decl(iteratorZip.ts, 231, 5)) ->Iterator.zipKeyed(instance, { mode: "longest", padding: { values: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a111 = Iterator.zipKeyed(a107, { mode: "longest", padding: { a: 0 } }).toArray(); +>a111 : Symbol(a111, Decl(iteratorZip.ts, 225, 5)) +>Iterator.zipKeyed(a107, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->instance : Symbol(instance, Decl(iteratorZip.ts, 227, 5)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 231, 53)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 231, 70)) ->values : Symbol(values, Decl(iteratorZip.ts, 231, 81)) +>a107 : Symbol(a107, Decl(iteratorZip.ts, 221, 5)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 225, 38)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 225, 55)) +>a : Symbol(a, Decl(iteratorZip.ts, 225, 66)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const hiddenInputs = { values: [1, 2], label: "inputs" }; ->hiddenInputs : Symbol(hiddenInputs, Decl(iteratorZip.ts, 233, 5)) ->values : Symbol(values, Decl(iteratorZip.ts, 233, 22)) ->label : Symbol(label, Decl(iteratorZip.ts, 233, 38)) +const a112 = { a: [1, 2], b: "inputs" }; +>a112 : Symbol(a112, Decl(iteratorZip.ts, 227, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 227, 14)) +>b : Symbol(b, Decl(iteratorZip.ts, 227, 25)) -Object.defineProperty(hiddenInputs, "label", { enumerable: false }); +Object.defineProperty(a112, "b", { enumerable: false }); >Object.defineProperty : Symbol(ObjectConstructor.defineProperty, Decl(lib.es5.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) >defineProperty : Symbol(ObjectConstructor.defineProperty, Decl(lib.es5.d.ts, --, --)) ->hiddenInputs : Symbol(hiddenInputs, Decl(iteratorZip.ts, 233, 5)) ->enumerable : Symbol(enumerable, Decl(iteratorZip.ts, 234, 46)) +>a112 : Symbol(a112, Decl(iteratorZip.ts, 227, 5)) +>enumerable : Symbol(enumerable, Decl(iteratorZip.ts, 228, 34)) -const nonEnumerable = Iterator.zipKeyed(hiddenInputs).toArray(); ->nonEnumerable : Symbol(nonEnumerable, Decl(iteratorZip.ts, 235, 5)) ->Iterator.zipKeyed(hiddenInputs).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a113 = Iterator.zipKeyed(a112).toArray(); +>a113 : Symbol(a113, Decl(iteratorZip.ts, 229, 5)) +>Iterator.zipKeyed(a112).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->hiddenInputs : Symbol(hiddenInputs, Decl(iteratorZip.ts, 233, 5)) +>a112 : Symbol(a112, Decl(iteratorZip.ts, 227, 5)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const nonEnumerablePadded = Iterator.zipKeyed(hiddenInputs, { mode: "longest", padding: { values: 0 } }).toArray(); ->nonEnumerablePadded : Symbol(nonEnumerablePadded, Decl(iteratorZip.ts, 236, 5)) ->Iterator.zipKeyed(hiddenInputs, { mode: "longest", padding: { values: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a114 = Iterator.zipKeyed(a112, { mode: "longest", padding: { a: 0 } }).toArray(); +>a114 : Symbol(a114, Decl(iteratorZip.ts, 230, 5)) +>Iterator.zipKeyed(a112, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->hiddenInputs : Symbol(hiddenInputs, Decl(iteratorZip.ts, 233, 5)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 236, 61)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 236, 78)) ->values : Symbol(values, Decl(iteratorZip.ts, 236, 89)) +>a112 : Symbol(a112, Decl(iteratorZip.ts, 227, 5)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 230, 38)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 230, 55)) +>a : Symbol(a, Decl(iteratorZip.ts, 230, 66)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -// The same static shape can have an enumerable non-iterator property instead. -// Such inputs are accepted by the fallback and checked at runtime. -const enumerableInputs = { values: [1, 2], label: "inputs" }; ->enumerableInputs : Symbol(enumerableInputs, Decl(iteratorZip.ts, 240, 5)) ->values : Symbol(values, Decl(iteratorZip.ts, 240, 26)) ->label : Symbol(label, Decl(iteratorZip.ts, 240, 42)) +const a115 = { a: [1, 2], b: "inputs" }; +>a115 : Symbol(a115, Decl(iteratorZip.ts, 232, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 232, 14)) +>b : Symbol(b, Decl(iteratorZip.ts, 232, 25)) -const enumerable = Iterator.zipKeyed(enumerableInputs).toArray(); ->enumerable : Symbol(enumerable, Decl(iteratorZip.ts, 241, 5)) ->Iterator.zipKeyed(enumerableInputs).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a116 = Iterator.zipKeyed(a115).toArray(); +>a116 : Symbol(a116, Decl(iteratorZip.ts, 233, 5)) +>Iterator.zipKeyed(a115).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->enumerableInputs : Symbol(enumerableInputs, Decl(iteratorZip.ts, 240, 5)) +>a115 : Symbol(a115, Decl(iteratorZip.ts, 232, 5)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -// The array's length and methods are not enumerable own properties. -const arrayInputs = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); ->arrayInputs : Symbol(arrayInputs, Decl(iteratorZip.ts, 244, 5)) +const a117 = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); +>a117 : Symbol(a117, Decl(iteratorZip.ts, 235, 5)) >Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -// The fallback must not claim that ignored properties exist on yielded objects. -const inheritedLabel: string = inherited[0].label; ->inheritedLabel : Symbol(inheritedLabel, Decl(iteratorZip.ts, 247, 5)) ->inherited : Symbol(inherited, Decl(iteratorZip.ts, 228, 5)) +const a118: string = a108[0].b; +>a118 : Symbol(a118, Decl(iteratorZip.ts, 237, 5)) +>a108 : Symbol(a108, Decl(iteratorZip.ts, 222, 5)) -const nonEnumerableLabel: string = nonEnumerable[0].label; ->nonEnumerableLabel : Symbol(nonEnumerableLabel, Decl(iteratorZip.ts, 248, 5)) ->nonEnumerable : Symbol(nonEnumerable, Decl(iteratorZip.ts, 235, 5)) +const a119: string = a113[0].b; +>a119 : Symbol(a119, Decl(iteratorZip.ts, 238, 5)) +>a113 : Symbol(a113, Decl(iteratorZip.ts, 229, 5)) -// Precise record inference still handles symbol keys and padding. -declare const ownKey: unique symbol; ->ownKey : Symbol(ownKey, Decl(iteratorZip.ts, 251, 13)) +declare const a120: unique symbol; +>a120 : Symbol(a120, Decl(iteratorZip.ts, 240, 13)) -const precise: { values: number; [ownKey]: string; }[] = Iterator.zipKeyed({ values: [1], [ownKey]: ["a"] }).toArray(); ->precise : Symbol(precise, Decl(iteratorZip.ts, 252, 5)) ->values : Symbol(values, Decl(iteratorZip.ts, 252, 16)) ->[ownKey] : Symbol([ownKey], Decl(iteratorZip.ts, 252, 32)) ->ownKey : Symbol(ownKey, Decl(iteratorZip.ts, 251, 13)) ->Iterator.zipKeyed({ values: [1], [ownKey]: ["a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a121: { a: number; [a120]: string; }[] = Iterator.zipKeyed({ a: [1], [a120]: ["a"] }).toArray(); +>a121 : Symbol(a121, Decl(iteratorZip.ts, 241, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 241, 13)) +>[a120] : Symbol([a120], Decl(iteratorZip.ts, 241, 24)) +>a120 : Symbol(a120, Decl(iteratorZip.ts, 240, 13)) +>Iterator.zipKeyed({ a: [1], [a120]: ["a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->values : Symbol(values, Decl(iteratorZip.ts, 252, 76)) ->[ownKey] : Symbol([ownKey], Decl(iteratorZip.ts, 252, 89)) ->ownKey : Symbol(ownKey, Decl(iteratorZip.ts, 251, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 241, 66)) +>[a120] : Symbol([a120], Decl(iteratorZip.ts, 241, 74)) +>a120 : Symbol(a120, Decl(iteratorZip.ts, 240, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const preciseLongest: { values: number | undefined; }[] = Iterator.zipKeyed({ values: [1] }, { mode: "longest" }).toArray(); ->preciseLongest : Symbol(preciseLongest, Decl(iteratorZip.ts, 253, 5)) ->values : Symbol(values, Decl(iteratorZip.ts, 253, 23)) ->Iterator.zipKeyed({ values: [1] }, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a122: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1] }, { mode: "longest" }).toArray(); +>a122 : Symbol(a122, Decl(iteratorZip.ts, 242, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 242, 13)) +>Iterator.zipKeyed({ a: [1] }, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->values : Symbol(values, Decl(iteratorZip.ts, 253, 77)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 253, 94)) +>a : Symbol(a, Decl(iteratorZip.ts, 242, 62)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 242, 74)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const precisePadded: { values: number; }[] = Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: 0 } }).toArray(); ->precisePadded : Symbol(precisePadded, Decl(iteratorZip.ts, 254, 5)) ->values : Symbol(values, Decl(iteratorZip.ts, 254, 22)) ->Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a123: { a: number; }[] = Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray(); +>a123 : Symbol(a123, Decl(iteratorZip.ts, 243, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 243, 13)) +>Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->values : Symbol(values, Decl(iteratorZip.ts, 254, 64)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 254, 81)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 254, 98)) ->values : Symbol(values, Decl(iteratorZip.ts, 254, 109)) +>a : Symbol(a, Decl(iteratorZip.ts, 243, 50)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 243, 62)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 243, 79)) +>a : Symbol(a, Decl(iteratorZip.ts, 243, 90)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const emptyOwnProperties: never[] = Iterator.zipKeyed({}).toArray(); ->emptyOwnProperties : Symbol(emptyOwnProperties, Decl(iteratorZip.ts, 255, 5)) ->Iterator.zipKeyed({}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +declare const a124: object; +>a124 : Symbol(a124, Decl(iteratorZip.ts, 245, 13)) + +const a125 = Iterator.zipKeyed(a124).toArray(); +>a125 : Symbol(a125, Decl(iteratorZip.ts, 246, 5)) +>Iterator.zipKeyed(a124).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a124 : Symbol(a124, Decl(iteratorZip.ts, 245, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a126 = Iterator.zipKeyed(a124, { mode: "strict" }).toArray(); +>a126 : Symbol(a126, Decl(iteratorZip.ts, 247, 5)) +>Iterator.zipKeyed(a124, { mode: "strict" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a124 : Symbol(a124, Decl(iteratorZip.ts, 245, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 247, 38)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a127 = Iterator.zipKeyed(a124, { mode: "longest" }).toArray(); +>a127 : Symbol(a127, Decl(iteratorZip.ts, 248, 5)) +>Iterator.zipKeyed(a124, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a124 : Symbol(a124, Decl(iteratorZip.ts, 245, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 248, 38)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a128 = Iterator.zipKeyed(a124, { mode: "longest", padding: { a: 0 } }).toArray(); +>a128 : Symbol(a128, Decl(iteratorZip.ts, 249, 5)) +>Iterator.zipKeyed(a124, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a124 : Symbol(a124, Decl(iteratorZip.ts, 245, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 249, 38)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 249, 55)) +>a : Symbol(a, Decl(iteratorZip.ts, 249, 66)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a129: unknown = a125[0].a; +>a129 : Symbol(a129, Decl(iteratorZip.ts, 250, 5)) +>a125 : Symbol(a125, Decl(iteratorZip.ts, 246, 5)) + +const a130: unknown = a126[0].a; +>a130 : Symbol(a130, Decl(iteratorZip.ts, 251, 5)) +>a126 : Symbol(a126, Decl(iteratorZip.ts, 247, 5)) + +const a131: unknown = a127[0].a; +>a131 : Symbol(a131, Decl(iteratorZip.ts, 252, 5)) +>a127 : Symbol(a127, Decl(iteratorZip.ts, 248, 5)) + +const a132: unknown = a128[0].a; +>a132 : Symbol(a132, Decl(iteratorZip.ts, 253, 5)) +>a128 : Symbol(a128, Decl(iteratorZip.ts, 249, 5)) + +const a133: never[] = a125; +>a133 : Symbol(a133, Decl(iteratorZip.ts, 254, 5)) +>a125 : Symbol(a125, Decl(iteratorZip.ts, 246, 5)) + +declare const a134: {}; +>a134 : Symbol(a134, Decl(iteratorZip.ts, 256, 13)) + +const a135 = Iterator.zipKeyed(a134).toArray(); +>a135 : Symbol(a135, Decl(iteratorZip.ts, 257, 5)) +>Iterator.zipKeyed(a134).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a134 : Symbol(a134, Decl(iteratorZip.ts, 256, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a136: unknown = a135[0].a; +>a136 : Symbol(a136, Decl(iteratorZip.ts, 258, 5)) +>a135 : Symbol(a135, Decl(iteratorZip.ts, 257, 5)) + +const a137: never[] = a135; +>a137 : Symbol(a137, Decl(iteratorZip.ts, 259, 5)) +>a135 : Symbol(a135, Decl(iteratorZip.ts, 257, 5)) + Iterator.zipKeyed(0); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) @@ -1334,35 +1403,35 @@ Iterator.zipKeyed(null); >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) -Iterator.zipKeyed(instance, { mode: "invalid" }); +Iterator.zipKeyed(a107, { mode: "invalid" }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->instance : Symbol(instance, Decl(iteratorZip.ts, 227, 5)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 259, 29)) +>a107 : Symbol(a107, Decl(iteratorZip.ts, 221, 5)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 263, 25)) -Iterator.zipKeyed(instance, { mode: "shortest", padding: {} }); +Iterator.zipKeyed(a107, { mode: "shortest", padding: {} }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->instance : Symbol(instance, Decl(iteratorZip.ts, 227, 5)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 260, 29)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 260, 47)) +>a107 : Symbol(a107, Decl(iteratorZip.ts, 221, 5)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 264, 25)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 264, 43)) -Iterator.zipKeyed(instance, { mode: "longest", padding: 0 }); +Iterator.zipKeyed(a107, { mode: "longest", padding: 0 }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->instance : Symbol(instance, Decl(iteratorZip.ts, 227, 5)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 261, 29)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 261, 46)) +>a107 : Symbol(a107, Decl(iteratorZip.ts, 221, 5)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 265, 25)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 265, 42)) -Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: "invalid" } }); +Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: "invalid" } }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->values : Symbol(values, Decl(iteratorZip.ts, 262, 19)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 262, 36)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 262, 53)) ->values : Symbol(values, Decl(iteratorZip.ts, 262, 64)) +>a : Symbol(a, Decl(iteratorZip.ts, 266, 19)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 266, 31)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 266, 48)) +>a : Symbol(a, Decl(iteratorZip.ts, 266, 59)) diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).types b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).types index 933da5476e72d..bf30fca89f801 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).types +++ b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).types @@ -1,11 +1,11 @@ //// [tests/cases/compiler/iteratorZip.ts] //// === iteratorZip.ts === -declare const key: unique symbol; ->key : unique symbol +declare const a1: unique symbol; +>a1 : unique symbol -const tuples: [number, string][] = Iterator.zip([ ->tuples : [number, string][] +const a2: [number, string][] = Iterator.zip([ +>a2 : [number, string][] >Iterator.zip([ [1, 2], new Set(["a", "b"]),] as const).toArray() : [1 | 2, string][] >Iterator.zip([ [1, 2], new Set(["a", "b"]),] as const).toArray : () => [1 | 2, string][] >Iterator.zip([ [1, 2], new Set(["a", "b"]),] as const) : IteratorObject<[1 | 2, string], undefined, unknown> @@ -30,17 +30,17 @@ const tuples: [number, string][] = Iterator.zip([ ] as const).toArray(); >toArray : () => [1 | 2, string][] -tuples[0][0] = 2; ->tuples[0][0] = 2 : 2 ->tuples[0][0] : number ->tuples[0] : [number, string] ->tuples : [number, string][] +a2[0][0] = 2; +>a2[0][0] = 2 : 2 +>a2[0][0] : number +>a2[0] : [number, string] +>a2 : [number, string][] >0 : 0 >0 : 0 >2 : 2 -const shortestTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray(); ->shortestTuples : [number, string][] +const a3: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray(); +>a3 : [number, string][] >Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray() : [1, "a"][] >Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray : () => [1, "a"][] >Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }) : IteratorObject<[1, "a"], undefined, unknown> @@ -58,8 +58,8 @@ const shortestTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { >"shortest" : "shortest" >toArray : () => [1, "a"][] -const strictTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray(); ->strictTuples : [number, string][] +const a4: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray(); +>a4 : [number, string][] >Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray() : [1, "a"][] >Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray : () => [1, "a"][] >Iterator.zip([[1], ["a"]] as const, { mode: "strict" }) : IteratorObject<[1, "a"], undefined, unknown> @@ -77,8 +77,8 @@ const strictTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { m >"strict" : "strict" >toArray : () => [1, "a"][] -const longestTuplesWithPadding: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray(); ->longestTuplesWithPadding : [number, string][] +const a5: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray(); +>a5 : [number, string][] >Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray() : [number, string][] >Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray : () => [number, string][] >Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }) : IteratorObject<[number, string], undefined, unknown> @@ -100,8 +100,8 @@ const longestTuplesWithPadding: [number, string][] = Iterator.zip([[1], ["a"]] a >"a" : "a" >toArray : () => [number, string][] -const longestTuplesWithoutPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray(); ->longestTuplesWithoutPadding : [number | undefined, string | undefined][] +const a6: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray(); +>a6 : [number | undefined, string | undefined][] >Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray() : [1 | undefined, "a" | undefined][] >Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray : () => [1 | undefined, "a" | undefined][] >Iterator.zip([[1], ["a"]] as const, { mode: "longest" }) : IteratorObject<[1 | undefined, "a" | undefined], undefined, unknown> @@ -119,8 +119,8 @@ const longestTuplesWithoutPadding: [number | undefined, string | undefined][] = >"longest" : "longest" >toArray : () => [1 | undefined, "a" | undefined][] -const longestTuplesWithPartialPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray(); ->longestTuplesWithPartialPadding : [number | undefined, string | undefined][] +const a7: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray(); +>a7 : [number | undefined, string | undefined][] >Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray() : [number, "a" | undefined][] >Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray : () => [number, "a" | undefined][] >Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }) : IteratorObject<[number, "a" | undefined], undefined, unknown> @@ -141,16 +141,16 @@ const longestTuplesWithPartialPadding: [number | undefined, string | undefined][ >1 : 1 >toArray : () => [number, "a" | undefined][] -declare const maybeLongestOptions: { mode: "shortest"; } | { mode: "longest"; }; ->maybeLongestOptions : { mode: "shortest"; } | { mode: "longest"; } +declare const a8: { mode: "shortest"; } | { mode: "longest"; }; +>a8 : { mode: "shortest"; } | { mode: "longest"; } >mode : "shortest" >mode : "longest" -const maybeLongestTuples: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray(); ->maybeLongestTuples : [number | undefined, string | undefined][] ->Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray() : [1 | undefined, "a" | undefined][] ->Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray : () => [1 | undefined, "a" | undefined][] ->Iterator.zip([[1], ["a"]] as const, maybeLongestOptions) : IteratorObject<[1 | undefined, "a" | undefined], undefined, unknown> +const a9: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, a8).toArray(); +>a9 : [number | undefined, string | undefined][] +>Iterator.zip([[1], ["a"]] as const, a8).toArray() : [1 | undefined, "a" | undefined][] +>Iterator.zip([[1], ["a"]] as const, a8).toArray : () => [1 | undefined, "a" | undefined][] +>Iterator.zip([[1], ["a"]] as const, a8) : IteratorObject<[1 | undefined, "a" | undefined], undefined, unknown> >Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor >zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } @@ -160,11 +160,11 @@ const maybeLongestTuples: [number | undefined, string | undefined][] = Iterator. >1 : 1 >["a"] : readonly ["a"] >"a" : "a" ->maybeLongestOptions : { mode: "shortest"; } | { mode: "longest"; } +>a8 : { mode: "shortest"; } | { mode: "longest"; } >toArray : () => [1 | undefined, "a" | undefined][] -const empty: never[] = Iterator.zip([]).toArray(); ->empty : never[] +const a10: never[] = Iterator.zip([]).toArray(); +>a10 : never[] >Iterator.zip([]).toArray() : never[] >Iterator.zip([]).toArray : () => never[] >Iterator.zip([]) : IteratorObject @@ -174,8 +174,8 @@ const empty: never[] = Iterator.zip([]).toArray(); >[] : [] >toArray : () => never[] -const emptyLongest: never[] = Iterator.zip([], { mode: "longest" }).toArray(); ->emptyLongest : never[] +const a11: never[] = Iterator.zip([], { mode: "longest" }).toArray(); +>a11 : never[] >Iterator.zip([], { mode: "longest" }).toArray() : never[] >Iterator.zip([], { mode: "longest" }).toArray : () => never[] >Iterator.zip([], { mode: "longest" }) : IteratorObject @@ -188,58 +188,58 @@ const emptyLongest: never[] = Iterator.zip([], { mode: "longest" }).toArray(); >"longest" : "longest" >toArray : () => never[] -declare const iterables: Iterable>; ->iterables : Iterable> +declare const a12: Iterable>; +>a12 : Iterable> -const arrays: number[][] = Iterator.zip(iterables).toArray(); ->arrays : number[][] ->Iterator.zip(iterables).toArray() : number[][] ->Iterator.zip(iterables).toArray : () => number[][] ->Iterator.zip(iterables) : IteratorObject +const a13: number[][] = Iterator.zip(a12).toArray(); +>a13 : number[][] +>Iterator.zip(a12).toArray() : number[][] +>Iterator.zip(a12).toArray : () => number[][] +>Iterator.zip(a12) : IteratorObject >Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor >zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->iterables : Iterable> +>a12 : Iterable> >toArray : () => number[][] -const longestArrays: (number | undefined)[][] = Iterator.zip(iterables, { mode: "longest" }).toArray(); ->longestArrays : (number | undefined)[][] ->Iterator.zip(iterables, { mode: "longest" }).toArray() : (number | undefined)[][] ->Iterator.zip(iterables, { mode: "longest" }).toArray : () => (number | undefined)[][] ->Iterator.zip(iterables, { mode: "longest" }) : IteratorObject<(number | undefined)[], undefined, unknown> +const a14: (number | undefined)[][] = Iterator.zip(a12, { mode: "longest" }).toArray(); +>a14 : (number | undefined)[][] +>Iterator.zip(a12, { mode: "longest" }).toArray() : (number | undefined)[][] +>Iterator.zip(a12, { mode: "longest" }).toArray : () => (number | undefined)[][] +>Iterator.zip(a12, { mode: "longest" }) : IteratorObject<(number | undefined)[], undefined, unknown> >Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor >zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->iterables : Iterable> +>a12 : Iterable> >{ mode: "longest" } : { mode: "longest"; } >mode : "longest" >"longest" : "longest" >toArray : () => (number | undefined)[][] -const maybeLongestArrays: (number | undefined)[][] = Iterator.zip(iterables, maybeLongestOptions).toArray(); ->maybeLongestArrays : (number | undefined)[][] ->Iterator.zip(iterables, maybeLongestOptions).toArray() : (number | undefined)[][] ->Iterator.zip(iterables, maybeLongestOptions).toArray : () => (number | undefined)[][] ->Iterator.zip(iterables, maybeLongestOptions) : IteratorObject<(number | undefined)[], undefined, unknown> +const a15: (number | undefined)[][] = Iterator.zip(a12, a8).toArray(); +>a15 : (number | undefined)[][] +>Iterator.zip(a12, a8).toArray() : (number | undefined)[][] +>Iterator.zip(a12, a8).toArray : () => (number | undefined)[][] +>Iterator.zip(a12, a8) : IteratorObject<(number | undefined)[], undefined, unknown> >Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor >zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->iterables : Iterable> ->maybeLongestOptions : { mode: "shortest"; } | { mode: "longest"; } +>a12 : Iterable> +>a8 : { mode: "shortest"; } | { mode: "longest"; } >toArray : () => (number | undefined)[][] -declare const iterableArray: Iterable[]; ->iterableArray : Iterable[] +declare const a16: Iterable[]; +>a16 : Iterable[] -const longestArrayWithPadding: (number | undefined)[][] = Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray(); ->longestArrayWithPadding : (number | undefined)[][] ->Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray() : (number | undefined)[][] ->Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray : () => (number | undefined)[][] ->Iterator.zip(iterableArray, { mode: "longest", padding: [] }) : IteratorObject<(number | undefined)[], undefined, unknown> +const a17: (number | undefined)[][] = Iterator.zip(a16, { mode: "longest", padding: [] }).toArray(); +>a17 : (number | undefined)[][] +>Iterator.zip(a16, { mode: "longest", padding: [] }).toArray() : (number | undefined)[][] +>Iterator.zip(a16, { mode: "longest", padding: [] }).toArray : () => (number | undefined)[][] +>Iterator.zip(a16, { mode: "longest", padding: [] }) : IteratorObject<(number | undefined)[], undefined, unknown> >Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor >zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->iterableArray : Iterable[] +>a16 : Iterable[] >{ mode: "longest", padding: [] } : { mode: "longest"; padding: []; } >mode : "longest" >"longest" : "longest" @@ -247,20 +247,20 @@ const longestArrayWithPadding: (number | undefined)[][] = Iterator.zip(iterableA >[] : [] >toArray : () => (number | undefined)[][] -const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ ->objects : { a: number; b: string; [key]: boolean; }[] +const a18: { a: number; b: string; [a1]: boolean; }[] = Iterator.zipKeyed({ +>a18 : { a: number; b: string; [a1]: boolean; }[] >a : number >b : string ->[key] : boolean ->key : unique symbol ->Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const).toArray() : { a: 1 | 2; b: string; [key]: boolean; }[] ->Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const).toArray : () => { a: 1 | 2; b: string; [key]: boolean; }[] ->Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const) : IteratorObject<{ a: 1 | 2; b: string; [key]: boolean; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>[a1] : boolean +>a1 : unique symbol +>Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [a1]: [true, false],} as const).toArray() : ({ a: 1 | 2; b: string; [a1]: boolean; } & {})[] +>Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [a1]: [true, false],} as const).toArray : () => ({ a: 1 | 2; b: string; [a1]: boolean; } & {})[] +>Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [a1]: [true, false],} as const) : IteratorObject<{ a: 1 | 2; b: string; [a1]: boolean; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->{ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const : { readonly a: readonly [1, 2]; readonly b: Set; readonly [key]: readonly [true, false]; } ->{ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} : { readonly a: readonly [1, 2]; readonly b: Set; readonly [key]: readonly [true, false]; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1, 2], b: new Set(["a", "b"]), [a1]: [true, false],} as const : { readonly a: readonly [1, 2]; readonly b: Set; readonly [a1]: readonly [true, false]; } +>{ a: [1, 2], b: new Set(["a", "b"]), [a1]: [true, false],} : { readonly a: readonly [1, 2]; readonly b: Set; readonly [a1]: readonly [true, false]; } a: [1, 2], >a : readonly [1, 2] @@ -276,35 +276,35 @@ const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ >"a" : "a" >"b" : "b" - [key]: [true, false], ->[key] : readonly [true, false] ->key : unique symbol + [a1]: [true, false], +>[a1] : readonly [true, false] +>a1 : unique symbol >[true, false] : readonly [true, false] >true : true >false : false } as const).toArray(); ->toArray : () => { a: 1 | 2; b: string; [key]: boolean; }[] +>toArray : () => ({ a: 1 | 2; b: string; [a1]: boolean; } & {})[] -objects[0].a = 2; ->objects[0].a = 2 : 2 ->objects[0].a : number ->objects[0] : { a: number; b: string; [key]: boolean; } ->objects : { a: number; b: string; [key]: boolean; }[] +a18[0].a = 2; +>a18[0].a = 2 : 2 +>a18[0].a : number +>a18[0] : { a: number; b: string; [a1]: boolean; } +>a18 : { a: number; b: string; [a1]: boolean; }[] >0 : 0 >a : number >2 : 2 -const longestObjectsWithPadding: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { ->longestObjectsWithPadding : { a: number; b: string; }[] +const a19: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +>a19 : { a: number; b: string; }[] >a : number >b : string ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}).toArray() : { a: number; b: string; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}).toArray : () => { a: number; b: string; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}) : IteratorObject<{ a: number; b: string; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}).toArray() : ({ a: number; b: string; } & {})[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}).toArray : () => ({ a: number; b: string; } & {})[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}) : IteratorObject<{ a: number; b: string; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >a : readonly [1] @@ -328,18 +328,18 @@ const longestObjectsWithPadding: { a: number; b: string; }[] = Iterator.zipKeyed >"a" : "a" }).toArray(); ->toArray : () => { a: number; b: string; }[] +>toArray : () => ({ a: number; b: string; } & {})[] -const longestObjectsWithoutPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { ->longestObjectsWithoutPadding : { a: number | undefined; b: string | undefined; }[] +const a20: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +>a20 : { a: number | undefined; b: string | undefined; }[] >a : number | undefined >b : string | undefined ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}).toArray() : { a: 1 | undefined; b: "a" | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}).toArray : () => { a: 1 | undefined; b: "a" | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}) : IteratorObject<{ a: 1 | undefined; b: "a" | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}).toArray() : ({ a: 1 | undefined; b: "a" | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}).toArray : () => ({ a: 1 | undefined; b: "a" | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}) : IteratorObject<{ a: 1 | undefined; b: "a" | undefined; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >a : readonly [1] @@ -355,18 +355,18 @@ const longestObjectsWithoutPadding: { a: number | undefined; b: string | undefin >"longest" : "longest" }).toArray(); ->toArray : () => { a: 1 | undefined; b: "a" | undefined; }[] +>toArray : () => ({ a: 1 | undefined; b: "a" | undefined; } & {})[] -const longestObjectsWithPartialPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { ->longestObjectsWithPartialPadding : { a: number | undefined; b: string | undefined; }[] +const a21: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +>a21 : { a: number | undefined; b: string | undefined; }[] >a : number | undefined >b : string | undefined ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}).toArray() : { a: 1 | undefined; b: string; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}).toArray : () => { a: 1 | undefined; b: string; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}) : IteratorObject<{ a: 1 | undefined; b: string; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}).toArray() : ({ a: 1 | undefined; b: string; } & {})[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}).toArray : () => ({ a: 1 | undefined; b: string; } & {})[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}) : IteratorObject<{ a: 1 | undefined; b: string; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >a : readonly [1] @@ -388,18 +388,18 @@ const longestObjectsWithPartialPadding: { a: number | undefined; b: string | und >"a" : "a" }).toArray(); ->toArray : () => { a: 1 | undefined; b: string; }[] +>toArray : () => ({ a: 1 | undefined; b: string; } & {})[] -const maybeLongestObjects: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray(); ->maybeLongestObjects : { a: number | undefined; b: string | undefined; }[] +const a22: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, a8).toArray(); +>a22 : { a: number | undefined; b: string | undefined; }[] >a : number | undefined >b : string | undefined ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray() : { a: 1 | undefined; b: "a" | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray : () => { a: 1 | undefined; b: "a" | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions) : IteratorObject<{ a: 1 | undefined; b: "a" | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, a8).toArray() : ({ a: 1 | undefined; b: "a" | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, a8).toArray : () => ({ a: 1 | undefined; b: "a" | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, a8) : IteratorObject<{ a: 1 | undefined; b: "a" | undefined; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >a : readonly [1] @@ -408,10 +408,10 @@ const maybeLongestObjects: { a: number | undefined; b: string | undefined; }[] = >b : readonly ["a"] >["a"] : readonly ["a"] >"a" : "a" ->maybeLongestOptions : { mode: "shortest"; } | { mode: "longest"; } ->toArray : () => { a: 1 | undefined; b: "a" | undefined; }[] +>a8 : { mode: "shortest"; } | { mode: "longest"; } +>toArray : () => ({ a: 1 | undefined; b: "a" | undefined; } & {})[] -interface Inputs { +interface I1 { a: Iterable; >a : Iterable @@ -419,21 +419,21 @@ interface Inputs { >b : Iterator } -declare const inputs: Inputs; ->inputs : Inputs +declare const a23: I1; +>a23 : I1 -const rows: { a: number; b: string; }[] = Iterator.zipKeyed(inputs).toArray(); ->rows : { a: number; b: string; }[] +const a24: { a: number; b: string; }[] = Iterator.zipKeyed(a23).toArray(); +>a24 : { a: number; b: string; }[] >a : number >b : string ->Iterator.zipKeyed(inputs).toArray() : { a: number; b: string; }[] ->Iterator.zipKeyed(inputs).toArray : () => { a: number; b: string; }[] ->Iterator.zipKeyed(inputs) : IteratorObject<{ a: number; b: string; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed(a23).toArray() : ({ a: number; b: string; } & {})[] +>Iterator.zipKeyed(a23).toArray : () => ({ a: number; b: string; } & {})[] +>Iterator.zipKeyed(a23) : IteratorObject<{ a: number; b: string; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->inputs : Inputs ->toArray : () => { a: number; b: string; }[] +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a23 : I1 +>toArray : () => ({ a: number; b: string; } & {})[] Iterator.zip([[1]], { mode: "invalid" }); >Iterator.zip([[1]], { mode: "invalid" }) : IteratorObject @@ -489,59 +489,57 @@ Iterator.zip(0); Iterator.zipKeyed({ a: 0 }); >Iterator.zipKeyed({ a: 0 }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: 0 } : { a: number; } >a : number >0 : 0 -const emptyKeyed: never[] = Iterator.zipKeyed({}).toArray(); ->emptyKeyed : never[] ->Iterator.zipKeyed({}).toArray() : never[] ->Iterator.zipKeyed({}).toArray : () => never[] ->Iterator.zipKeyed({}) : IteratorObject ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a25: Record[] = Iterator.zipKeyed({}).toArray(); +>a25 : Record[] +>Iterator.zipKeyed({}).toArray() : Record[] +>Iterator.zipKeyed({}).toArray : () => Record[] +>Iterator.zipKeyed({}) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{} : {} ->toArray : () => never[] +>toArray : () => Record[] -const emptyKeyedLongest: never[] = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); ->emptyKeyedLongest : never[] ->Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray() : never[] ->Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray : () => never[] ->Iterator.zipKeyed({}, { mode: "longest", padding: {} }) : IteratorObject ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a26: Record[] = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); +>a26 : Record[] +>Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray() : Record[] +>Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray : () => Record[] +>Iterator.zipKeyed({}, { mode: "longest", padding: {} }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{} : {} >{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } >mode : "longest" >"longest" : "longest" >padding : {} >{} : {} ->toArray : () => never[] +>toArray : () => Record[] -declare const unionInputs: { a: Iterable; } | { b: Iterator; }; ->unionInputs : { a: Iterable; } | { b: Iterator; } +declare const a27: { a: Iterable; } | { b: Iterator; }; +>a27 : { a: Iterable; } | { b: Iterator; } >a : Iterable >b : Iterator -const unionRows: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(unionInputs).toArray(); ->unionRows : ({ a: number; } | { b: string; })[] +const a28: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(a27).toArray(); +>a28 : ({ a: number; } | { b: string; })[] >a : number >b : string ->Iterator.zipKeyed(unionInputs).toArray() : ({ a: number; } | { b: string; })[] ->Iterator.zipKeyed(unionInputs).toArray : () => ({ a: number; } | { b: string; })[] ->Iterator.zipKeyed(unionInputs) : IteratorObject<{ a: number; } | { b: string; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed(a27).toArray() : (({ a: number; } & {}) | ({ b: string; } & {}))[] +>Iterator.zipKeyed(a27).toArray : () => (({ a: number; } & {}) | ({ b: string; } & {}))[] +>Iterator.zipKeyed(a27) : IteratorObject<({ a: number; } & {}) | ({ b: string; } & {}), undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->unionInputs : { a: Iterable; } | { b: Iterator; } ->toArray : () => ({ a: number; } | { b: string; })[] - -// Inputs +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a27 : { a: Iterable; } | { b: Iterator; } +>toArray : () => (({ a: number; } & {}) | ({ b: string; } & {}))[] Iterator.zip("ab"); >Iterator.zip("ab") : IteratorObject @@ -569,17 +567,17 @@ Iterator.zip(new Set(["ab"])); >"ab" : "ab" Iterator.zipKeyed("ab"); ->Iterator.zipKeyed("ab") : IteratorObject ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed("ab") : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >"ab" : "ab" Iterator.zipKeyed({ a: "ab" }); >Iterator.zipKeyed({ a: "ab" }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: "ab" } : { a: string; } >a : string >"ab" : "ab" @@ -611,10 +609,10 @@ Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); >"ab" : "ab" Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); ->Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }) : IteratorObject ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{} : {} >{ mode: "longest", padding: "ab" } : { mode: "longest"; padding: string; } >mode : "longest" @@ -622,8 +620,8 @@ Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); >padding : string >"ab" : "ab" -const a: [string][] = Iterator.zip([new String("ab")]).toArray(); ->a : [string][] +const a29: [string][] = Iterator.zip([new String("ab")]).toArray(); +>a29 : [string][] >Iterator.zip([new String("ab")]).toArray() : [string][] >Iterator.zip([new String("ab")]).toArray : () => [string][] >Iterator.zip([new String("ab")]) : IteratorObject<[string], undefined, unknown> @@ -636,24 +634,24 @@ const a: [string][] = Iterator.zip([new String("ab")]).toArray(); >"ab" : "ab" >toArray : () => [string][] -const b: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); ->b : { a: string; }[] +const a30: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); +>a30 : { a: string; }[] >a : string ->Iterator.zipKeyed({ a: new String("ab") }).toArray() : { a: string; }[] ->Iterator.zipKeyed({ a: new String("ab") }).toArray : () => { a: string; }[] ->Iterator.zipKeyed({ a: new String("ab") }) : IteratorObject<{ a: string; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed({ a: new String("ab") }).toArray() : ({ a: string; } & {})[] +>Iterator.zipKeyed({ a: new String("ab") }).toArray : () => ({ a: string; } & {})[] +>Iterator.zipKeyed({ a: new String("ab") }) : IteratorObject<{ a: string; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: new String("ab") } : { a: String; } >a : String >new String("ab") : String >String : StringConstructor >"ab" : "ab" ->toArray : () => { a: string; }[] +>toArray : () => ({ a: string; } & {})[] -const c: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); ->c : (string | undefined)[][] +const a31: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); +>a31 : (string | undefined)[][] >Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray() : (string | undefined)[][] >Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray : () => (string | undefined)[][] >Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }) : IteratorObject<(string | undefined)[], undefined, unknown> @@ -672,55 +670,55 @@ const c: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", pad >"ab" : "ab" >toArray : () => (string | undefined)[][] -const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); ->d : { a: number; }[] ->Iterator.zipKeyed({ a: [1], b: undefined }).toArray() : { a: number; }[] ->Iterator.zipKeyed({ a: [1], b: undefined }).toArray : () => { a: number; }[] ->Iterator.zipKeyed({ a: [1], b: undefined }) : IteratorObject<{ a: number; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a32 = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); +>a32 : ({ a: number; } & {})[] +>Iterator.zipKeyed({ a: [1], b: undefined }).toArray() : ({ a: number; } & {})[] +>Iterator.zipKeyed({ a: [1], b: undefined }).toArray : () => ({ a: number; } & {})[] +>Iterator.zipKeyed({ a: [1], b: undefined }) : IteratorObject<{ a: number; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: [1], b: undefined } : { a: number[]; b: undefined; } >a : number[] >[1] : number[] >1 : 1 >b : undefined >undefined : undefined ->toArray : () => { a: number; }[] +>toArray : () => ({ a: number; } & {})[] -const e: { a: number; }[] = d; ->e : { a: number; }[] +const a33: { a: number; }[] = a32; +>a33 : { a: number; }[] >a : number ->d : { a: number; }[] +>a32 : ({ a: number; } & {})[] -d[0].b; ->d[0].b : any ->d[0] : { a: number; } ->d : { a: number; }[] +a32[0].b; +>a32[0].b : any +>a32[0] : { a: number; } & {} +>a32 : ({ a: number; } & {})[] >0 : 0 >b : any -const f: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); ->f : never[] +const a34: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); +>a34 : never[] >Iterator.zipKeyed({ a: undefined }).toArray() : never[] >Iterator.zipKeyed({ a: undefined }).toArray : () => never[] >Iterator.zipKeyed({ a: undefined }) : IteratorObject ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: undefined } : { a: undefined; } >a : undefined >undefined : undefined >toArray : () => never[] -const g: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); ->g : never[] +const a35: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); +>a35 : never[] >Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray() : never[] >Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray : () => never[] >Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }) : IteratorObject ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: undefined } : { a: undefined; } >a : undefined >undefined : undefined @@ -731,7 +729,7 @@ const g: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", paddin >{} : {} >toArray : () => never[] -interface I { +interface I2 { readonly a: Iterable; >a : Iterable @@ -744,193 +742,193 @@ interface I { readonly d?: undefined; >d : undefined } -declare const h: I; ->h : I - -const i = Iterator.zipKeyed(h).toArray(); ->i : { a: number; b?: string | undefined; c?: boolean | undefined; }[] ->Iterator.zipKeyed(h).toArray() : { a: number; b?: string | undefined; c?: boolean | undefined; }[] ->Iterator.zipKeyed(h).toArray : () => { a: number; b?: string | undefined; c?: boolean | undefined; }[] ->Iterator.zipKeyed(h) : IteratorObject<{ a: number; b?: string | undefined; c?: boolean | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->h : I ->toArray : () => { a: number; b?: string | undefined; c?: boolean | undefined; }[] - -const j: { a: number; b?: string; c?: boolean; }[] = i; ->j : { a: number; b?: string; c?: boolean; }[] +declare const a36: I2; +>a36 : I2 + +const a37 = Iterator.zipKeyed(a36).toArray(); +>a37 : ({ a: number; } & { b?: string | undefined; c?: boolean | undefined; })[] +>Iterator.zipKeyed(a36).toArray() : ({ a: number; } & { b?: string | undefined; c?: boolean | undefined; })[] +>Iterator.zipKeyed(a36).toArray : () => ({ a: number; } & { b?: string | undefined; c?: boolean | undefined; })[] +>Iterator.zipKeyed(a36) : IteratorObject<{ a: number; } & { b?: string | undefined; c?: boolean | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a36 : I2 +>toArray : () => ({ a: number; } & { b?: string | undefined; c?: boolean | undefined; })[] + +const a38: { a: number; b?: string; c?: boolean; }[] = a37; +>a38 : { a: number; b?: string; c?: boolean; }[] >a : number >b : string | undefined >c : boolean | undefined ->i : { a: number; b?: string | undefined; c?: boolean | undefined; }[] +>a37 : ({ a: number; } & { b?: string | undefined; c?: boolean | undefined; })[] -i[0].a = 2; ->i[0].a = 2 : 2 ->i[0].a : number ->i[0] : { a: number; b?: string | undefined; c?: boolean | undefined; } ->i : { a: number; b?: string | undefined; c?: boolean | undefined; }[] +a37[0].a = 2; +>a37[0].a = 2 : 2 +>a37[0].a : number +>a37[0] : { a: number; } & { b?: string | undefined; c?: boolean | undefined; } +>a37 : ({ a: number; } & { b?: string | undefined; c?: boolean | undefined; })[] >0 : 0 >a : number >2 : 2 -i[0].b = "a"; ->i[0].b = "a" : "a" ->i[0].b : string | undefined ->i[0] : { a: number; b?: string | undefined; c?: boolean | undefined; } ->i : { a: number; b?: string | undefined; c?: boolean | undefined; }[] +a37[0].b = "a"; +>a37[0].b = "a" : "a" +>a37[0].b : string | undefined +>a37[0] : { a: number; } & { b?: string | undefined; c?: boolean | undefined; } +>a37 : ({ a: number; } & { b?: string | undefined; c?: boolean | undefined; })[] >0 : 0 >b : string | undefined >"a" : "a" -i[0].c = true; ->i[0].c = true : true ->i[0].c : boolean | undefined ->i[0] : { a: number; b?: string | undefined; c?: boolean | undefined; } ->i : { a: number; b?: string | undefined; c?: boolean | undefined; }[] +a37[0].c = true; +>a37[0].c = true : true +>a37[0].c : boolean | undefined +>a37[0] : { a: number; } & { b?: string | undefined; c?: boolean | undefined; } +>a37 : ({ a: number; } & { b?: string | undefined; c?: boolean | undefined; })[] >0 : 0 >c : boolean | undefined >true : true -i[0].d; ->i[0].d : any ->i[0] : { a: number; b?: string | undefined; c?: boolean | undefined; } ->i : { a: number; b?: string | undefined; c?: boolean | undefined; }[] +a37[0].d; +>a37[0].d : any +>a37[0] : { a: number; } & { b?: string | undefined; c?: boolean | undefined; } +>a37 : ({ a: number; } & { b?: string | undefined; c?: boolean | undefined; })[] >0 : 0 >d : any -const k: { a: number; c: boolean; }[] = i; ->k : { a: number; c: boolean; }[] +const a39: { a: number; c: boolean; }[] = a37; +>a39 : { a: number; c: boolean; }[] >a : number >c : boolean ->i : { a: number; b?: string | undefined; c?: boolean | undefined; }[] +>a37 : ({ a: number; } & { b?: string | undefined; c?: boolean | undefined; })[] -const l: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); ->l : { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] +const a40: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(a36, { mode: "longest" }).toArray(); +>a40 : { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] >a : number | undefined >b : string | undefined >c : boolean | undefined ->Iterator.zipKeyed(h, { mode: "longest" }).toArray() : { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] ->Iterator.zipKeyed(h, { mode: "longest" }).toArray : () => { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] ->Iterator.zipKeyed(h, { mode: "longest" }) : IteratorObject<{ a: number | undefined; b?: string | undefined; c?: boolean | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed(a36, { mode: "longest" }).toArray() : ({ a: number | undefined; } & { b?: string | undefined; c?: boolean | undefined; })[] +>Iterator.zipKeyed(a36, { mode: "longest" }).toArray : () => ({ a: number | undefined; } & { b?: string | undefined; c?: boolean | undefined; })[] +>Iterator.zipKeyed(a36, { mode: "longest" }) : IteratorObject<{ a: number | undefined; } & { b?: string | undefined; c?: boolean | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->h : I +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a36 : I2 >{ mode: "longest" } : { mode: "longest"; } >mode : "longest" >"longest" : "longest" ->toArray : () => { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] +>toArray : () => ({ a: number | undefined; } & { b?: string | undefined; c?: boolean | undefined; })[] -declare const m: { a: Iterable; } | { b: Iterator; }; ->m : { a: Iterable; } | { b: Iterator; } +declare const a41: { a: Iterable; } | { b: Iterator; }; +>a41 : { a: Iterable; } | { b: Iterator; } >a : Iterable >b : Iterator -const n: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(m).toArray(); ->n : ({ a: number; } | { b: string; })[] +const a42: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(a41).toArray(); +>a42 : ({ a: number; } | { b: string; })[] >a : number >b : string ->Iterator.zipKeyed(m).toArray() : ({ a: number; } | { b: string; })[] ->Iterator.zipKeyed(m).toArray : () => ({ a: number; } | { b: string; })[] ->Iterator.zipKeyed(m) : IteratorObject<{ a: number; } | { b: string; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed(a41).toArray() : (({ a: number; } & {}) | ({ b: string; } & {}))[] +>Iterator.zipKeyed(a41).toArray : () => (({ a: number; } & {}) | ({ b: string; } & {}))[] +>Iterator.zipKeyed(a41) : IteratorObject<({ a: number; } & {}) | ({ b: string; } & {}), undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->m : { a: Iterable; } | { b: Iterator; } ->toArray : () => ({ a: number; } | { b: string; })[] +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a41 : { a: Iterable; } | { b: Iterator; } +>toArray : () => (({ a: number; } & {}) | ({ b: string; } & {}))[] -declare const o: { a: Iterable; } | { b: number; }; ->o : { a: Iterable; } | { b: number; } +declare const a43: { a: Iterable; } | { b: number; }; +>a43 : { a: Iterable; } | { b: number; } >a : Iterable >b : number -Iterator.zipKeyed(o); ->Iterator.zipKeyed(o) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +Iterator.zipKeyed(a43); +>Iterator.zipKeyed(a43) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->o : { a: Iterable; } | { b: number; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a43 : { a: Iterable; } | { b: number; } -Iterator.zipKeyed(o, { mode: "longest" }); ->Iterator.zipKeyed(o, { mode: "longest" }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +Iterator.zipKeyed(a43, { mode: "longest" }); +>Iterator.zipKeyed(a43, { mode: "longest" }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->o : { a: Iterable; } | { b: number; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a43 : { a: Iterable; } | { b: number; } >{ mode: "longest" } : { mode: "longest"; } >mode : "longest" >"longest" : "longest" -Iterator.zipKeyed(o, { mode: "longest", padding: {} }); ->Iterator.zipKeyed(o, { mode: "longest", padding: {} }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +Iterator.zipKeyed(a43, { mode: "longest", padding: {} }); +>Iterator.zipKeyed(a43, { mode: "longest", padding: {} }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->o : { a: Iterable; } | { b: number; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a43 : { a: Iterable; } | { b: number; } >{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } >mode : "longest" >"longest" : "longest" >padding : {} >{} : {} -declare const p: { a?: Iterable; } | { b: string; }; ->p : { a?: Iterable; } | { b: string; } +declare const a44: { a?: Iterable; } | { b: string; }; +>a44 : { a?: Iterable; } | { b: string; } >a : Iterable | undefined >b : string -Iterator.zipKeyed(p); ->Iterator.zipKeyed(p) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +Iterator.zipKeyed(a44); +>Iterator.zipKeyed(a44) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->p : { a?: Iterable; } | { b: string; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a44 : { a?: Iterable; } | { b: string; } -declare const q: { a: Iterable; } | { b: undefined; }; ->q : { a: Iterable; } | { b: undefined; } +declare const a45: { a: Iterable; } | { b: undefined; }; +>a45 : { a: Iterable; } | { b: undefined; } >a : Iterable >b : undefined -const r: { a: number; }[] = Iterator.zipKeyed(q).toArray(); ->r : { a: number; }[] +const a46: { a: number; }[] = Iterator.zipKeyed(a45).toArray(); +>a46 : { a: number; }[] >a : number ->Iterator.zipKeyed(q).toArray() : { a: number; }[] ->Iterator.zipKeyed(q).toArray : () => { a: number; }[] ->Iterator.zipKeyed(q) : IteratorObject<{ a: number; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed(a45).toArray() : ({ a: number; } & {})[] +>Iterator.zipKeyed(a45).toArray : () => ({ a: number; } & {})[] +>Iterator.zipKeyed(a45) : IteratorObject<{ a: number; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->q : { a: Iterable; } | { b: undefined; } ->toArray : () => { a: number; }[] +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a45 : { a: Iterable; } | { b: undefined; } +>toArray : () => ({ a: number; } & {})[] -declare const s: unique symbol; ->s : unique symbol +declare const a47: unique symbol; +>a47 : unique symbol -declare const t: { a: Iterable; [s]?: Iterable; }; ->t : { a: Iterable; [s]?: Iterable; } +declare const a48: { a: Iterable; [a47]?: Iterable; }; +>a48 : { a: Iterable; [a47]?: Iterable; } >a : Iterable ->[s] : Iterable | undefined ->s : unique symbol +>[a47] : Iterable | undefined +>a47 : unique symbol -const u: { a: number; [s]?: string; }[] = Iterator.zipKeyed(t).toArray(); ->u : { a: number; [s]?: string; }[] +const a49: { a: number; [a47]?: string; }[] = Iterator.zipKeyed(a48).toArray(); +>a49 : { a: number; [a47]?: string; }[] >a : number ->[s] : string | undefined ->s : unique symbol ->Iterator.zipKeyed(t).toArray() : { a: number; [s]?: string | undefined; }[] ->Iterator.zipKeyed(t).toArray : () => { a: number; [s]?: string | undefined; }[] ->Iterator.zipKeyed(t) : IteratorObject<{ a: number; [s]?: string | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>[a47] : string | undefined +>a47 : unique symbol +>Iterator.zipKeyed(a48).toArray() : ({ a: number; } & { [a47]?: string | undefined; })[] +>Iterator.zipKeyed(a48).toArray : () => ({ a: number; } & { [a47]?: string | undefined; })[] +>Iterator.zipKeyed(a48) : IteratorObject<{ a: number; } & { [a47]?: string | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->t : { a: Iterable; [s]?: Iterable; } ->toArray : () => { a: number; [s]?: string | undefined; }[] +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a48 : { a: Iterable; [a47]?: Iterable; } +>toArray : () => ({ a: number; } & { [a47]?: string | undefined; })[] Iterator.zipKeyed({ a: [1], b: null }); >Iterator.zipKeyed({ a: [1], b: null }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: [1], b: null } : { a: number[]; b: null; } >a : number[] >[1] : number[] @@ -939,9 +937,9 @@ Iterator.zipKeyed({ a: [1], b: null }); Iterator.zipKeyed({ a: [1], b: false }); >Iterator.zipKeyed({ a: [1], b: false }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: [1], b: false } : { a: number[]; b: false; } >a : number[] >[1] : number[] @@ -957,30 +955,30 @@ Iterator.zip([undefined]); >[undefined] : [undefined] >undefined : undefined -declare const v: { a?: undefined; }; ->v : { a?: undefined; } +declare const a50: { a?: undefined; }; +>a50 : { a?: undefined; } >a : undefined -const w: never[] = Iterator.zipKeyed(v).toArray(); ->w : never[] ->Iterator.zipKeyed(v).toArray() : never[] ->Iterator.zipKeyed(v).toArray : () => never[] ->Iterator.zipKeyed(v) : IteratorObject ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a51: never[] = Iterator.zipKeyed(a50).toArray(); +>a51 : never[] +>Iterator.zipKeyed(a50).toArray() : never[] +>Iterator.zipKeyed(a50).toArray : () => never[] +>Iterator.zipKeyed(a50) : IteratorObject +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->v : { a?: undefined; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a50 : { a?: undefined; } >toArray : () => never[] -const x: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); ->x : { a: number; }[] +const a52: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); +>a52 : { a: number; }[] >a : number ->Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray() : { a: number; }[] ->Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray : () => { a: number; }[] ->Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }) : IteratorObject<{ a: number; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray() : ({ a: number; } & {})[] +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray : () => ({ a: number; } & {})[] +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }) : IteratorObject<{ a: number; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: [1], b: undefined } : { a: number[]; b: undefined; } >a : number[] >[1] : number[] @@ -994,17 +992,17 @@ const x: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: >{ a: 0 } : { a: number; } >a : number >0 : 0 ->toArray : () => { a: number; }[] +>toArray : () => ({ a: number; } & {})[] -const y: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); ->y : { a: number | undefined; }[] +const a53: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); +>a53 : { a: number | undefined; }[] >a : number | undefined ->Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray() : { a: number | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray : () => { a: number | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }) : IteratorObject<{ a: number | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray() : ({ a: number | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray : () => ({ a: number | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }) : IteratorObject<{ a: number | undefined; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: [1], b: undefined } : { a: number[]; b: undefined; } >a : number[] >[1] : number[] @@ -1014,7 +1012,7 @@ const y: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined >{ mode: "longest" } : { mode: "longest"; } >mode : "longest" >"longest" : "longest" ->toArray : () => { a: number | undefined; }[] +>toArray : () => ({ a: number | undefined; } & {})[] function f1(a: Iterable) { >f1 : (a: Iterable) => { b: { a: T; }[]; c: [T][]; } @@ -1023,15 +1021,15 @@ function f1(a: Iterable) { const b: { a: T; }[] = Iterator.zipKeyed({ a }).toArray(); >b : { a: T; }[] >a : T ->Iterator.zipKeyed({ a }).toArray() : { a: T; }[] ->Iterator.zipKeyed({ a }).toArray : () => { a: T; }[] ->Iterator.zipKeyed({ a }) : IteratorObject<{ a: T; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K] | undefined; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K] | undefined; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K] | undefined; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed({ a }).toArray() : ({ a: T; } & {})[] +>Iterator.zipKeyed({ a }).toArray : () => ({ a: T; } & {})[] +>Iterator.zipKeyed({ a }) : IteratorObject<{ a: T; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K] | undefined; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K] | undefined; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K] | undefined; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a } : { a: Iterable; } >a : Iterable ->toArray : () => { a: T; }[] +>toArray : () => ({ a: T; } & {})[] const c: [T][] = Iterator.zip([a]).toArray(); >c : [T][] @@ -1051,10 +1049,8 @@ function f1(a: Iterable) { >c : [T][] } -// Padding - -const paddingA: [Iterable, ...Iterable[]] = [[1, 2], [3]]; ->paddingA : [Iterable, ...Iterable[]] +const a54: [Iterable, ...Iterable[]] = [[1, 2], [3]]; +>a54 : [Iterable, ...Iterable[]] >[[1, 2], [3]] : [number[], number[]] >[1, 2] : number[] >1 : 1 @@ -1062,15 +1058,15 @@ const paddingA: [Iterable, ...Iterable[]] = [[1, 2], [3]]; >[3] : number[] >3 : 3 -const paddingB = Iterator.zip(paddingA, { mode: "longest", padding: [0] }).toArray(); ->paddingB : [number, ...(number | undefined)[]][] ->Iterator.zip(paddingA, { mode: "longest", padding: [0] }).toArray() : [number, ...(number | undefined)[]][] ->Iterator.zip(paddingA, { mode: "longest", padding: [0] }).toArray : () => [number, ...(number | undefined)[]][] ->Iterator.zip(paddingA, { mode: "longest", padding: [0] }) : IteratorObject<[number, ...(number | undefined)[]], undefined, unknown> +const a55 = Iterator.zip(a54, { mode: "longest", padding: [0] }).toArray(); +>a55 : [number, ...(number | undefined)[]][] +>Iterator.zip(a54, { mode: "longest", padding: [0] }).toArray() : [number, ...(number | undefined)[]][] +>Iterator.zip(a54, { mode: "longest", padding: [0] }).toArray : () => [number, ...(number | undefined)[]][] +>Iterator.zip(a54, { mode: "longest", padding: [0] }) : IteratorObject<[number, ...(number | undefined)[]], undefined, unknown> >Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor >zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->paddingA : [Iterable, ...Iterable[]] +>a54 : [Iterable, ...Iterable[]] >{ mode: "longest", padding: [0] } : { mode: "longest"; padding: [number]; } >mode : "longest" >"longest" : "longest" @@ -1079,16 +1075,16 @@ const paddingB = Iterator.zip(paddingA, { mode: "longest", padding: [0] }).toArr >0 : 0 >toArray : () => [number, ...(number | undefined)[]][] -const paddingC: (number | undefined)[][] = paddingB; ->paddingC : (number | undefined)[][] ->paddingB : [number, ...(number | undefined)[]][] +const a56: (number | undefined)[][] = a55; +>a56 : (number | undefined)[][] +>a55 : [number, ...(number | undefined)[]][] -const paddingD: number[][] = paddingB; ->paddingD : number[][] ->paddingB : [number, ...(number | undefined)[]][] +const a57: number[][] = a55; +>a57 : number[][] +>a55 : [number, ...(number | undefined)[]][] -const paddingE: Record> = { a: [1], b: [2, 3] }; ->paddingE : Record> +const a58: Record> = { a: [1], b: [2, 3] }; +>a58 : Record> >{ a: [1], b: [2, 3] } : { a: number[]; b: number[]; } >a : number[] >[1] : number[] @@ -1098,41 +1094,41 @@ const paddingE: Record> = { a: [1], b: [2, 3] }; >2 : 2 >3 : 3 -const paddingF = Iterator.zipKeyed(paddingE, { mode: "longest", padding: {} }).toArray(); ->paddingF : { [x: string]: number | undefined; }[] ->Iterator.zipKeyed(paddingE, { mode: "longest", padding: {} }).toArray() : { [x: string]: number | undefined; }[] ->Iterator.zipKeyed(paddingE, { mode: "longest", padding: {} }).toArray : () => { [x: string]: number | undefined; }[] ->Iterator.zipKeyed(paddingE, { mode: "longest", padding: {} }) : IteratorObject<{ [x: string]: number | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a59 = Iterator.zipKeyed(a58, { mode: "longest", padding: {} }).toArray(); +>a59 : ({ [x: string]: number | undefined; } & {})[] +>Iterator.zipKeyed(a58, { mode: "longest", padding: {} }).toArray() : ({ [x: string]: number | undefined; } & {})[] +>Iterator.zipKeyed(a58, { mode: "longest", padding: {} }).toArray : () => ({ [x: string]: number | undefined; } & {})[] +>Iterator.zipKeyed(a58, { mode: "longest", padding: {} }) : IteratorObject<{ [x: string]: number | undefined; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->paddingE : Record> +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a58 : Record> >{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } >mode : "longest" >"longest" : "longest" >padding : {} >{} : {} ->toArray : () => { [x: string]: number | undefined; }[] +>toArray : () => ({ [x: string]: number | undefined; } & {})[] -const paddingG: Record[] = paddingF; ->paddingG : Record[] ->paddingF : { [x: string]: number | undefined; }[] +const a60: Record[] = a59; +>a60 : Record[] +>a59 : ({ [x: string]: number | undefined; } & {})[] -const paddingH: Record[] = paddingF; ->paddingH : Record[] ->paddingF : { [x: string]: number | undefined; }[] +const a61: Record[] = a59; +>a61 : Record[] +>a59 : ({ [x: string]: number | undefined; } & {})[] -declare const paddingI: Record; ->paddingI : Record +declare const a62: Record; +>a62 : Record -const paddingJ = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: paddingI }).toArray(); ->paddingJ : { a: number | undefined; b: number | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: paddingI }).toArray() : { a: number | undefined; b: number | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: paddingI }).toArray : () => { a: number | undefined; b: number | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: paddingI }) : IteratorObject<{ a: number | undefined; b: number | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a63 = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a62 }).toArray(); +>a63 : ({ a: number | undefined; b: number | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a62 }).toArray() : ({ a: number | undefined; b: number | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a62 }).toArray : () => ({ a: number | undefined; b: number | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a62 }) : IteratorObject<{ a: number | undefined; b: number | undefined; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: [1], b: [2, 3] } : { a: number[]; b: number[]; } >a : number[] >[1] : number[] @@ -1141,27 +1137,27 @@ const paddingJ = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", pad >[2, 3] : number[] >2 : 2 >3 : 3 ->{ mode: "longest", padding: paddingI } : { mode: "longest"; padding: Record; } +>{ mode: "longest", padding: a62 } : { mode: "longest"; padding: Record; } >mode : "longest" >"longest" : "longest" >padding : Record ->paddingI : Record ->toArray : () => { a: number | undefined; b: number | undefined; }[] +>a62 : Record +>toArray : () => ({ a: number | undefined; b: number | undefined; } & {})[] -const paddingK: { a: number | undefined; b: number | undefined; }[] = paddingJ; ->paddingK : { a: number | undefined; b: number | undefined; }[] +const a64: { a: number | undefined; b: number | undefined; }[] = a63; +>a64 : { a: number | undefined; b: number | undefined; }[] >a : number | undefined >b : number | undefined ->paddingJ : { a: number | undefined; b: number | undefined; }[] +>a63 : ({ a: number | undefined; b: number | undefined; } & {})[] -const paddingL: { a: number; b: number; }[] = paddingJ; ->paddingL : { a: number; b: number; }[] +const a65: { a: number; b: number; }[] = a63; +>a65 : { a: number; b: number; }[] >a : number >b : number ->paddingJ : { a: number | undefined; b: number | undefined; }[] +>a63 : ({ a: number | undefined; b: number | undefined; } & {})[] -const paddingM = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); ->paddingM : [number, string][] +const a66 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); +>a66 : [number, string][] >Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray() : [number, string][] >Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray : () => [number, string][] >Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }) : IteratorObject<[number, string], undefined, unknown> @@ -1182,18 +1178,18 @@ const paddingM = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] >"" : "" >toArray : () => [number, string][] -const paddingN: [number, string][] = paddingM; ->paddingN : [number, string][] ->paddingM : [number, string][] +const a67: [number, string][] = a66; +>a67 : [number, string][] +>a66 : [number, string][] -const paddingO = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); ->paddingO : { a: number; b: string; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray() : { a: number; b: string; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray : () => { a: number; b: string; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }) : IteratorObject<{ a: number; b: string; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a68 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); +>a68 : ({ a: number; b: string; } & {})[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray() : ({ a: number; b: string; } & {})[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray : () => ({ a: number; b: string; } & {})[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }) : IteratorObject<{ a: number; b: string; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } >a : number[] >[1] : number[] @@ -1210,16 +1206,16 @@ const paddingO = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padd >0 : 0 >b : string >"" : "" ->toArray : () => { a: number; b: string; }[] +>toArray : () => ({ a: number; b: string; } & {})[] -const paddingP: { a: number; b: string; }[] = paddingO; ->paddingP : { a: number; b: string; }[] +const a69: { a: number; b: string; }[] = a68; +>a69 : { a: number; b: string; }[] >a : number >b : string ->paddingO : { a: number; b: string; }[] +>a68 : ({ a: number; b: string; } & {})[] -const paddingQ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); ->paddingQ : [number, string | undefined][] +const a70 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); +>a70 : [number, string | undefined][] >Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray() : [number, string | undefined][] >Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray : () => [number, string | undefined][] >Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }) : IteratorObject<[number, string | undefined], undefined, unknown> @@ -1239,22 +1235,22 @@ const paddingQ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).t >0 : 0 >toArray : () => [number, string | undefined][] -const paddingR: [number | undefined, string | undefined][] = paddingQ; ->paddingR : [number | undefined, string | undefined][] ->paddingQ : [number, string | undefined][] +const a71: [number | undefined, string | undefined][] = a70; +>a71 : [number | undefined, string | undefined][] +>a70 : [number, string | undefined][] -const paddingS: [number, string][] = paddingQ; ->paddingS : [number, string][] ->paddingQ : [number, string | undefined][] +const a72: [number, string][] = a70; +>a72 : [number, string][] +>a70 : [number, string | undefined][] -const paddingT = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); ->paddingT : { a: number; b: string | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray() : { a: number; b: string | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray : () => { a: number; b: string | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }) : IteratorObject<{ a: number; b: string | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a73 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); +>a73 : ({ a: number; b: string | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray() : ({ a: number; b: string | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray : () => ({ a: number; b: string | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }) : IteratorObject<{ a: number; b: string | undefined; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } >a : number[] >[1] : number[] @@ -1269,28 +1265,28 @@ const paddingT = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padd >{ a: 0 } : { a: number; } >a : number >0 : 0 ->toArray : () => { a: number; b: string | undefined; }[] +>toArray : () => ({ a: number; b: string | undefined; } & {})[] -const paddingU: { a: number | undefined; b: string | undefined; }[] = paddingT; ->paddingU : { a: number | undefined; b: string | undefined; }[] +const a74: { a: number | undefined; b: string | undefined; }[] = a73; +>a74 : { a: number | undefined; b: string | undefined; }[] >a : number | undefined >b : string | undefined ->paddingT : { a: number; b: string | undefined; }[] +>a73 : ({ a: number; b: string | undefined; } & {})[] -const paddingV: { a: number; b: string; }[] = paddingT; ->paddingV : { a: number; b: string; }[] +const a75: { a: number; b: string; }[] = a73; +>a75 : { a: number; b: string; }[] >a : number >b : string ->paddingT : { a: number; b: string | undefined; }[] +>a73 : ({ a: number; b: string | undefined; } & {})[] -declare const paddingW: readonly [number, string]; ->paddingW : readonly [number, string] +declare const a76: readonly [number, string]; +>a76 : readonly [number, string] -const paddingX: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingW }).toArray(); ->paddingX : [number, string][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingW }).toArray() : [number, string][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingW }).toArray : () => [number, string][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingW }) : IteratorObject<[number, string], undefined, unknown> +const a77: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a76 }).toArray(); +>a77 : [number, string][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: a76 }).toArray() : [number, string][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: a76 }).toArray : () => [number, string][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: a76 }) : IteratorObject<[number, string], undefined, unknown> >Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor >zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } @@ -1299,21 +1295,21 @@ const paddingX: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest >1 : 1 >["a"] : string[] >"a" : "a" ->{ mode: "longest", padding: paddingW } : { mode: "longest"; padding: readonly [number, string]; } +>{ mode: "longest", padding: a76 } : { mode: "longest"; padding: readonly [number, string]; } >mode : "longest" >"longest" : "longest" >padding : readonly [number, string] ->paddingW : readonly [number, string] +>a76 : readonly [number, string] >toArray : () => [number, string][] -declare const paddingY: [number, string?]; ->paddingY : [number, (string | undefined)?] +declare const a78: [number, string?]; +>a78 : [number, (string | undefined)?] -const paddingZ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY }).toArray(); ->paddingZ : [number, string | undefined][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY }).toArray() : [number, string | undefined][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY }).toArray : () => [number, string | undefined][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY }) : IteratorObject<[number, string | undefined], undefined, unknown> +const a79 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a78 }).toArray(); +>a79 : [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: a78 }).toArray() : [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: a78 }).toArray : () => [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: a78 }) : IteratorObject<[number, string | undefined], undefined, unknown> >Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor >zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } @@ -1322,29 +1318,29 @@ const paddingZ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY >1 : 1 >["a"] : string[] >"a" : "a" ->{ mode: "longest", padding: paddingY } : { mode: "longest"; padding: [number, (string | undefined)?]; } +>{ mode: "longest", padding: a78 } : { mode: "longest"; padding: [number, (string | undefined)?]; } >mode : "longest" >"longest" : "longest" >padding : [number, (string | undefined)?] ->paddingY : [number, (string | undefined)?] +>a78 : [number, (string | undefined)?] >toArray : () => [number, string | undefined][] -const paddingA1: [number, string][] = paddingZ; ->paddingA1 : [number, string][] ->paddingZ : [number, string | undefined][] +const a80: [number, string][] = a79; +>a80 : [number, string][] +>a79 : [number, string | undefined][] -declare const paddingB1: [Iterable] | [Iterable, Iterable]; ->paddingB1 : [Iterable] | [Iterable, Iterable] +declare const a81: [Iterable] | [Iterable, Iterable]; +>a81 : [Iterable] | [Iterable, Iterable] -const paddingC1 = Iterator.zip(paddingB1, { mode: "longest", padding: [0] }).toArray(); ->paddingC1 : ([number] | [number, number | undefined])[] ->Iterator.zip(paddingB1, { mode: "longest", padding: [0] }).toArray() : ([number] | [number, number | undefined])[] ->Iterator.zip(paddingB1, { mode: "longest", padding: [0] }).toArray : () => ([number] | [number, number | undefined])[] ->Iterator.zip(paddingB1, { mode: "longest", padding: [0] }) : IteratorObject<[number] | [number, number | undefined], undefined, unknown> +const a82 = Iterator.zip(a81, { mode: "longest", padding: [0] }).toArray(); +>a82 : ([number] | [number, number | undefined])[] +>Iterator.zip(a81, { mode: "longest", padding: [0] }).toArray() : ([number] | [number, number | undefined])[] +>Iterator.zip(a81, { mode: "longest", padding: [0] }).toArray : () => ([number] | [number, number | undefined])[] +>Iterator.zip(a81, { mode: "longest", padding: [0] }) : IteratorObject<[number] | [number, number | undefined], undefined, unknown> >Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor >zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->paddingB1 : [Iterable] | [Iterable, Iterable] +>a81 : [Iterable] | [Iterable, Iterable] >{ mode: "longest", padding: [0] } : { mode: "longest"; padding: [number]; } >mode : "longest" >"longest" : "longest" @@ -1353,24 +1349,24 @@ const paddingC1 = Iterator.zip(paddingB1, { mode: "longest", padding: [0] }).toA >0 : 0 >toArray : () => ([number] | [number, number | undefined])[] -const paddingD1: number[][] = paddingC1; ->paddingD1 : number[][] ->paddingC1 : ([number] | [number, number | undefined])[] +const a83: number[][] = a82; +>a83 : number[][] +>a82 : ([number] | [number, number | undefined])[] -declare const paddingE1: { a: Iterable; } | { b: Iterable; }; ->paddingE1 : { a: Iterable; } | { b: Iterable; } +declare const a84: { a: Iterable; } | { b: Iterable; }; +>a84 : { a: Iterable; } | { b: Iterable; } >a : Iterable >b : Iterable -const paddingF1 = Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: 0 } }).toArray(); ->paddingF1 : ({ a: number; } | { b: string | undefined; })[] ->Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: 0 } }).toArray() : ({ a: number; } | { b: string | undefined; })[] ->Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: 0 } }).toArray : () => ({ a: number; } | { b: string | undefined; })[] ->Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: 0 } }) : IteratorObject<{ a: number; } | { b: string | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a85 = Iterator.zipKeyed(a84, { mode: "longest", padding: { a: 0 } }).toArray(); +>a85 : (({ a: number; } & {}) | ({ b: string | undefined; } & {}))[] +>Iterator.zipKeyed(a84, { mode: "longest", padding: { a: 0 } }).toArray() : (({ a: number; } & {}) | ({ b: string | undefined; } & {}))[] +>Iterator.zipKeyed(a84, { mode: "longest", padding: { a: 0 } }).toArray : () => (({ a: number; } & {}) | ({ b: string | undefined; } & {}))[] +>Iterator.zipKeyed(a84, { mode: "longest", padding: { a: 0 } }) : IteratorObject<({ a: number; } & {}) | ({ b: string | undefined; } & {}), undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->paddingE1 : { a: Iterable; } | { b: Iterable; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a84 : { a: Iterable; } | { b: Iterable; } >{ mode: "longest", padding: { a: 0 } } : { mode: "longest"; padding: { a: number; }; } >mode : "longest" >"longest" : "longest" @@ -1378,27 +1374,27 @@ const paddingF1 = Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: >{ a: 0 } : { a: number; } >a : number >0 : 0 ->toArray : () => ({ a: number; } | { b: string | undefined; })[] +>toArray : () => (({ a: number; } & {}) | ({ b: string | undefined; } & {}))[] -const paddingG1: ({ a: number; } | { b: string; })[] = paddingF1; ->paddingG1 : ({ a: number; } | { b: string; })[] +const a86: ({ a: number; } | { b: string; })[] = a85; +>a86 : ({ a: number; } | { b: string; })[] >a : number >b : string ->paddingF1 : ({ a: number; } | { b: string | undefined; })[] +>a85 : (({ a: number; } & {}) | ({ b: string | undefined; } & {}))[] -declare const paddingH1: { a: number; } | { b: string; }; ->paddingH1 : { a: number; } | { b: string; } +declare const a87: { a: number; } | { b: string; }; +>a87 : { a: number; } | { b: string; } >a : number >b : string -const paddingI1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: paddingH1 }).toArray(); ->paddingI1 : { a: number | undefined; b: string | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: paddingH1 }).toArray() : { a: number | undefined; b: string | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: paddingH1 }).toArray : () => { a: number | undefined; b: string | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: paddingH1 }) : IteratorObject<{ a: number | undefined; b: string | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a88 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: a87 }).toArray(); +>a88 : ({ a: number | undefined; b: string | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: a87 }).toArray() : ({ a: number | undefined; b: string | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: a87 }).toArray : () => ({ a: number | undefined; b: string | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: a87 }) : IteratorObject<{ a: number | undefined; b: string | undefined; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } >a : number[] >[1] : number[] @@ -1406,27 +1402,27 @@ const paddingI1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", pad >b : string[] >["a"] : string[] >"a" : "a" ->{ mode: "longest", padding: paddingH1 } : { mode: "longest"; padding: { a: number; } | { b: string; }; } +>{ mode: "longest", padding: a87 } : { mode: "longest"; padding: { a: number; } | { b: string; }; } >mode : "longest" >"longest" : "longest" >padding : { a: number; } | { b: string; } ->paddingH1 : { a: number; } | { b: string; } ->toArray : () => { a: number | undefined; b: string | undefined; }[] +>a87 : { a: number; } | { b: string; } +>toArray : () => ({ a: number | undefined; b: string | undefined; } & {})[] -const paddingJ1: { a: number; b: string; }[] = paddingI1; ->paddingJ1 : { a: number; b: string; }[] +const a89: { a: number; b: string; }[] = a88; +>a89 : { a: number; b: string; }[] >a : number >b : string ->paddingI1 : { a: number | undefined; b: string | undefined; }[] +>a88 : ({ a: number | undefined; b: string | undefined; } & {})[] -const paddingK1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); ->paddingK1 : { a: number | undefined; b: number; }[] ->Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray() : { a: number | undefined; b: number; }[] ->Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray : () => { a: number | undefined; b: number; }[] ->Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }) : IteratorObject<{ a: number | undefined; b: number; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a90 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); +>a90 : ({ a: number | undefined; b: number; } & {})[] +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray() : ({ a: number | undefined; b: number; } & {})[] +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray : () => ({ a: number | undefined; b: number; } & {})[] +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }) : IteratorObject<{ a: number | undefined; b: number; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: [1], b: [2] } : { a: number[]; b: number[]; } >a : number[] >[1] : number[] @@ -1443,77 +1439,77 @@ const paddingK1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", paddi >undefined : undefined >b : number >0 : 0 ->toArray : () => { a: number | undefined; b: number; }[] +>toArray : () => ({ a: number | undefined; b: number; } & {})[] -const paddingL1: { a: number; b: number; }[] = paddingK1; ->paddingL1 : { a: number; b: number; }[] +const a91: { a: number; b: number; }[] = a90; +>a91 : { a: number; b: number; }[] >a : number >b : number ->paddingK1 : { a: number | undefined; b: number; }[] +>a90 : ({ a: number | undefined; b: number; } & {})[] -declare const paddingM1: { [K in `a${string}`]: Iterable; }; ->paddingM1 : { [x: `a${string}`]: Iterable; } +declare const a92: { [K in `a${string}`]: Iterable; }; +>a92 : { [x: `a${string}`]: Iterable; } -const paddingN1 = Iterator.zipKeyed(paddingM1, { mode: "longest", padding: {} }).toArray(); ->paddingN1 : { [x: `a${string}`]: number | undefined; }[] ->Iterator.zipKeyed(paddingM1, { mode: "longest", padding: {} }).toArray() : { [x: `a${string}`]: number | undefined; }[] ->Iterator.zipKeyed(paddingM1, { mode: "longest", padding: {} }).toArray : () => { [x: `a${string}`]: number | undefined; }[] ->Iterator.zipKeyed(paddingM1, { mode: "longest", padding: {} }) : IteratorObject<{ [x: `a${string}`]: number | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a93 = Iterator.zipKeyed(a92, { mode: "longest", padding: {} }).toArray(); +>a93 : ({ [x: `a${string}`]: number | undefined; } & {})[] +>Iterator.zipKeyed(a92, { mode: "longest", padding: {} }).toArray() : ({ [x: `a${string}`]: number | undefined; } & {})[] +>Iterator.zipKeyed(a92, { mode: "longest", padding: {} }).toArray : () => ({ [x: `a${string}`]: number | undefined; } & {})[] +>Iterator.zipKeyed(a92, { mode: "longest", padding: {} }) : IteratorObject<{ [x: `a${string}`]: number | undefined; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->paddingM1 : { [x: `a${string}`]: Iterable; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a92 : { [x: `a${string}`]: Iterable; } >{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } >mode : "longest" >"longest" : "longest" >padding : {} >{} : {} ->toArray : () => { [x: `a${string}`]: number | undefined; }[] - -const paddingO1: { [K in `a${string}`]: number; }[] = paddingN1; ->paddingO1 : { [x: `a${string}`]: number; }[] ->paddingN1 : { [x: `a${string}`]: number | undefined; }[] - -declare const paddingP1: unique symbol; ->paddingP1 : unique symbol - -const paddingQ1: { [paddingP1]: number; }[] = Iterator.zipKeyed({ [paddingP1]: [1] }, { mode: "longest", padding: { [paddingP1]: 0 } }).toArray(); ->paddingQ1 : { [paddingP1]: number; }[] ->[paddingP1] : number ->paddingP1 : unique symbol ->Iterator.zipKeyed({ [paddingP1]: [1] }, { mode: "longest", padding: { [paddingP1]: 0 } }).toArray() : { [paddingP1]: number; }[] ->Iterator.zipKeyed({ [paddingP1]: [1] }, { mode: "longest", padding: { [paddingP1]: 0 } }).toArray : () => { [paddingP1]: number; }[] ->Iterator.zipKeyed({ [paddingP1]: [1] }, { mode: "longest", padding: { [paddingP1]: 0 } }) : IteratorObject<{ [paddingP1]: number; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->{ [paddingP1]: [1] } : { [paddingP1]: number[]; } ->[paddingP1] : number[] ->paddingP1 : unique symbol +>toArray : () => ({ [x: `a${string}`]: number | undefined; } & {})[] + +const a94: { [K in `a${string}`]: number; }[] = a93; +>a94 : { [x: `a${string}`]: number; }[] +>a93 : ({ [x: `a${string}`]: number | undefined; } & {})[] + +declare const a95: unique symbol; +>a95 : unique symbol + +const a96: { [a95]: number; }[] = Iterator.zipKeyed({ [a95]: [1] }, { mode: "longest", padding: { [a95]: 0 } }).toArray(); +>a96 : { [a95]: number; }[] +>[a95] : number +>a95 : unique symbol +>Iterator.zipKeyed({ [a95]: [1] }, { mode: "longest", padding: { [a95]: 0 } }).toArray() : ({ [a95]: number; } & {})[] +>Iterator.zipKeyed({ [a95]: [1] }, { mode: "longest", padding: { [a95]: 0 } }).toArray : () => ({ [a95]: number; } & {})[] +>Iterator.zipKeyed({ [a95]: [1] }, { mode: "longest", padding: { [a95]: 0 } }) : IteratorObject<{ [a95]: number; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ [a95]: [1] } : { [a95]: number[]; } +>[a95] : number[] +>a95 : unique symbol >[1] : number[] >1 : 1 ->{ mode: "longest", padding: { [paddingP1]: 0 } } : { mode: "longest"; padding: { [paddingP1]: number; }; } +>{ mode: "longest", padding: { [a95]: 0 } } : { mode: "longest"; padding: { [a95]: number; }; } >mode : "longest" >"longest" : "longest" ->padding : { [paddingP1]: number; } ->{ [paddingP1]: 0 } : { [paddingP1]: number; } ->[paddingP1] : number ->paddingP1 : unique symbol +>padding : { [a95]: number; } +>{ [a95]: 0 } : { [a95]: number; } +>[a95] : number +>a95 : unique symbol >0 : 0 ->toArray : () => { [paddingP1]: number; }[] +>toArray : () => ({ [a95]: number; } & {})[] -declare const paddingR1: Record & { a: number; }; ->paddingR1 : Record & { a: number; } +declare const a97: Record & { a: number; }; +>a97 : Record & { a: number; } >a : number -const paddingS1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: paddingR1 }).toArray(); ->paddingS1 : { a: number; b: number | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: paddingR1 }).toArray() : { a: number; b: number | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: paddingR1 }).toArray : () => { a: number; b: number | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: paddingR1 }) : IteratorObject<{ a: number; b: number | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a98 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: a97 }).toArray(); +>a98 : ({ a: number; b: number | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: a97 }).toArray() : ({ a: number; b: number | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: a97 }).toArray : () => ({ a: number; b: number | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: a97 }) : IteratorObject<{ a: number; b: number | undefined; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: [1], b: [2] } : { a: number[]; b: number[]; } >a : number[] >[1] : number[] @@ -1521,33 +1517,33 @@ const paddingS1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", paddi >b : number[] >[2] : number[] >2 : 2 ->{ mode: "longest", padding: paddingR1 } : { mode: "longest"; padding: Record & { a: number; }; } +>{ mode: "longest", padding: a97 } : { mode: "longest"; padding: Record & { a: number; }; } >mode : "longest" >"longest" : "longest" >padding : Record & { a: number; } ->paddingR1 : Record & { a: number; } ->toArray : () => { a: number; b: number | undefined; }[] +>a97 : Record & { a: number; } +>toArray : () => ({ a: number; b: number | undefined; } & {})[] -const paddingT1: { a: number; b: number | undefined; }[] = paddingS1; ->paddingT1 : { a: number; b: number | undefined; }[] +const a99: { a: number; b: number | undefined; }[] = a98; +>a99 : { a: number; b: number | undefined; }[] >a : number >b : number | undefined ->paddingS1 : { a: number; b: number | undefined; }[] +>a98 : ({ a: number; b: number | undefined; } & {})[] -const paddingU1: { a: number; b: number; }[] = paddingS1; ->paddingU1 : { a: number; b: number; }[] +const a100: { a: number; b: number; }[] = a98; +>a100 : { a: number; b: number; }[] >a : number >b : number ->paddingS1 : { a: number; b: number | undefined; }[] +>a98 : ({ a: number; b: number | undefined; } & {})[] -declare const paddingV1: [number] | [number, string]; ->paddingV1 : [number] | [number, string] +declare const a101: [number] | [number, string]; +>a101 : [number] | [number, string] -const paddingW1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingV1 }).toArray(); ->paddingW1 : [number, string | undefined][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingV1 }).toArray() : [number, string | undefined][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingV1 }).toArray : () => [number, string | undefined][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingV1 }) : IteratorObject<[number, string | undefined], undefined, unknown> +const a102 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a101 }).toArray(); +>a102 : [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: a101 }).toArray() : [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: a101 }).toArray : () => [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: a101 }) : IteratorObject<[number, string | undefined], undefined, unknown> >Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor >zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } @@ -1556,23 +1552,23 @@ const paddingW1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: padding >1 : 1 >["a"] : string[] >"a" : "a" ->{ mode: "longest", padding: paddingV1 } : { mode: "longest"; padding: [number] | [number, string]; } +>{ mode: "longest", padding: a101 } : { mode: "longest"; padding: [number] | [number, string]; } >mode : "longest" >"longest" : "longest" >padding : [number] | [number, string] ->paddingV1 : [number] | [number, string] +>a101 : [number] | [number, string] >toArray : () => [number, string | undefined][] -const paddingX1: [number, string | undefined][] = paddingW1; ->paddingX1 : [number, string | undefined][] ->paddingW1 : [number, string | undefined][] +const a103: [number, string | undefined][] = a102; +>a103 : [number, string | undefined][] +>a102 : [number, string | undefined][] -const paddingY1: [number, string][] = paddingW1; ->paddingY1 : [number, string][] ->paddingW1 : [number, string | undefined][] +const a104: [number, string][] = a102; +>a104 : [number, string][] +>a102 : [number, string | undefined][] -const paddingZ1: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); ->paddingZ1 : [number | undefined, number][] +const a105: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); +>a105 : [number | undefined, number][] >Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray() : [number | undefined, number][] >Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray : () => [number | undefined, number][] >Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }) : IteratorObject<[number | undefined, number], undefined, unknown> @@ -1593,184 +1589,179 @@ const paddingZ1: [number | undefined, number][] = Iterator.zip([[1], [2]], { mod >0 : 0 >toArray : () => [number | undefined, number][] -const paddingA2: { a: number | undefined; b: number; }[] = paddingK1; ->paddingA2 : { a: number | undefined; b: number; }[] +const a106: { a: number | undefined; b: number; }[] = a90; +>a106 : { a: number | undefined; b: number; }[] >a : number | undefined >b : number ->paddingK1 : { a: number | undefined; b: number; }[] +>a90 : ({ a: number | undefined; b: number; } & {})[] -// Own properties +class C1 { +>C1 : C1 -class InputsWithPrototypeMembers { ->InputsWithPrototypeMembers : InputsWithPrototypeMembers - - values = [1, 2]; ->values : number[] + a = [1, 2]; +>a : number[] >[1, 2] : number[] >1 : 1 >2 : 2 - get label() { ->label : string + get b() { +>b : string return "inputs"; >"inputs" : "inputs" } - describe() { ->describe : () => string + f() { +>f : () => string - return this.label; ->this.label : string + return this.b; +>this.b : string >this : this ->label : string +>b : string } } -const instance = new InputsWithPrototypeMembers(); ->instance : InputsWithPrototypeMembers ->new InputsWithPrototypeMembers() : InputsWithPrototypeMembers ->InputsWithPrototypeMembers : typeof InputsWithPrototypeMembers +const a107 = new C1(); +>a107 : C1 +>new C1() : C1 +>C1 : typeof C1 -const inherited = Iterator.zipKeyed(instance).toArray(); ->inherited : Record[] ->Iterator.zipKeyed(instance).toArray() : Record[] ->Iterator.zipKeyed(instance).toArray : () => Record[] ->Iterator.zipKeyed(instance) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a108 = Iterator.zipKeyed(a107).toArray(); +>a108 : Record[] +>Iterator.zipKeyed(a107).toArray() : Record[] +>Iterator.zipKeyed(a107).toArray : () => Record[] +>Iterator.zipKeyed(a107) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->instance : InputsWithPrototypeMembers +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a107 : C1 >toArray : () => Record[] -const inheritedStrict = Iterator.zipKeyed(instance, { mode: "strict" }).toArray(); ->inheritedStrict : Record[] ->Iterator.zipKeyed(instance, { mode: "strict" }).toArray() : Record[] ->Iterator.zipKeyed(instance, { mode: "strict" }).toArray : () => Record[] ->Iterator.zipKeyed(instance, { mode: "strict" }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a109 = Iterator.zipKeyed(a107, { mode: "strict" }).toArray(); +>a109 : Record[] +>Iterator.zipKeyed(a107, { mode: "strict" }).toArray() : Record[] +>Iterator.zipKeyed(a107, { mode: "strict" }).toArray : () => Record[] +>Iterator.zipKeyed(a107, { mode: "strict" }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->instance : InputsWithPrototypeMembers +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a107 : C1 >{ mode: "strict" } : { mode: "strict"; } >mode : "strict" >"strict" : "strict" >toArray : () => Record[] -const inheritedLongest = Iterator.zipKeyed(instance, { mode: "longest" }).toArray(); ->inheritedLongest : Record[] ->Iterator.zipKeyed(instance, { mode: "longest" }).toArray() : Record[] ->Iterator.zipKeyed(instance, { mode: "longest" }).toArray : () => Record[] ->Iterator.zipKeyed(instance, { mode: "longest" }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a110 = Iterator.zipKeyed(a107, { mode: "longest" }).toArray(); +>a110 : Record[] +>Iterator.zipKeyed(a107, { mode: "longest" }).toArray() : Record[] +>Iterator.zipKeyed(a107, { mode: "longest" }).toArray : () => Record[] +>Iterator.zipKeyed(a107, { mode: "longest" }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->instance : InputsWithPrototypeMembers +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a107 : C1 >{ mode: "longest" } : { mode: "longest"; } >mode : "longest" >"longest" : "longest" >toArray : () => Record[] -const inheritedPadded = Iterator.zipKeyed(instance, { mode: "longest", padding: { values: 0 } }).toArray(); ->inheritedPadded : Record[] ->Iterator.zipKeyed(instance, { mode: "longest", padding: { values: 0 } }).toArray() : Record[] ->Iterator.zipKeyed(instance, { mode: "longest", padding: { values: 0 } }).toArray : () => Record[] ->Iterator.zipKeyed(instance, { mode: "longest", padding: { values: 0 } }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a111 = Iterator.zipKeyed(a107, { mode: "longest", padding: { a: 0 } }).toArray(); +>a111 : Record[] +>Iterator.zipKeyed(a107, { mode: "longest", padding: { a: 0 } }).toArray() : Record[] +>Iterator.zipKeyed(a107, { mode: "longest", padding: { a: 0 } }).toArray : () => Record[] +>Iterator.zipKeyed(a107, { mode: "longest", padding: { a: 0 } }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->instance : InputsWithPrototypeMembers ->{ mode: "longest", padding: { values: 0 } } : { mode: "longest"; padding: { values: number; }; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a107 : C1 +>{ mode: "longest", padding: { a: 0 } } : { mode: "longest"; padding: { a: number; }; } >mode : "longest" >"longest" : "longest" ->padding : { values: number; } ->{ values: 0 } : { values: number; } ->values : number +>padding : { a: number; } +>{ a: 0 } : { a: number; } +>a : number >0 : 0 >toArray : () => Record[] -const hiddenInputs = { values: [1, 2], label: "inputs" }; ->hiddenInputs : { values: number[]; label: string; } ->{ values: [1, 2], label: "inputs" } : { values: number[]; label: string; } ->values : number[] +const a112 = { a: [1, 2], b: "inputs" }; +>a112 : { a: number[]; b: string; } +>{ a: [1, 2], b: "inputs" } : { a: number[]; b: string; } +>a : number[] >[1, 2] : number[] >1 : 1 >2 : 2 ->label : string +>b : string >"inputs" : "inputs" -Object.defineProperty(hiddenInputs, "label", { enumerable: false }); ->Object.defineProperty(hiddenInputs, "label", { enumerable: false }) : { values: number[]; label: string; } +Object.defineProperty(a112, "b", { enumerable: false }); +>Object.defineProperty(a112, "b", { enumerable: false }) : { a: number[]; b: string; } >Object.defineProperty : (o: T, p: PropertyKey, attributes: PropertyDescriptor & ThisType) => T >Object : ObjectConstructor >defineProperty : (o: T, p: PropertyKey, attributes: PropertyDescriptor & ThisType) => T ->hiddenInputs : { values: number[]; label: string; } ->"label" : "label" +>a112 : { a: number[]; b: string; } +>"b" : "b" >{ enumerable: false } : { enumerable: false; } >enumerable : false >false : false -const nonEnumerable = Iterator.zipKeyed(hiddenInputs).toArray(); ->nonEnumerable : Record[] ->Iterator.zipKeyed(hiddenInputs).toArray() : Record[] ->Iterator.zipKeyed(hiddenInputs).toArray : () => Record[] ->Iterator.zipKeyed(hiddenInputs) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a113 = Iterator.zipKeyed(a112).toArray(); +>a113 : Record[] +>Iterator.zipKeyed(a112).toArray() : Record[] +>Iterator.zipKeyed(a112).toArray : () => Record[] +>Iterator.zipKeyed(a112) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->hiddenInputs : { values: number[]; label: string; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a112 : { a: number[]; b: string; } >toArray : () => Record[] -const nonEnumerablePadded = Iterator.zipKeyed(hiddenInputs, { mode: "longest", padding: { values: 0 } }).toArray(); ->nonEnumerablePadded : Record[] ->Iterator.zipKeyed(hiddenInputs, { mode: "longest", padding: { values: 0 } }).toArray() : Record[] ->Iterator.zipKeyed(hiddenInputs, { mode: "longest", padding: { values: 0 } }).toArray : () => Record[] ->Iterator.zipKeyed(hiddenInputs, { mode: "longest", padding: { values: 0 } }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a114 = Iterator.zipKeyed(a112, { mode: "longest", padding: { a: 0 } }).toArray(); +>a114 : Record[] +>Iterator.zipKeyed(a112, { mode: "longest", padding: { a: 0 } }).toArray() : Record[] +>Iterator.zipKeyed(a112, { mode: "longest", padding: { a: 0 } }).toArray : () => Record[] +>Iterator.zipKeyed(a112, { mode: "longest", padding: { a: 0 } }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->hiddenInputs : { values: number[]; label: string; } ->{ mode: "longest", padding: { values: 0 } } : { mode: "longest"; padding: { values: number; }; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a112 : { a: number[]; b: string; } +>{ mode: "longest", padding: { a: 0 } } : { mode: "longest"; padding: { a: number; }; } >mode : "longest" >"longest" : "longest" ->padding : { values: number; } ->{ values: 0 } : { values: number; } ->values : number +>padding : { a: number; } +>{ a: 0 } : { a: number; } +>a : number >0 : 0 >toArray : () => Record[] -// The same static shape can have an enumerable non-iterator property instead. -// Such inputs are accepted by the fallback and checked at runtime. -const enumerableInputs = { values: [1, 2], label: "inputs" }; ->enumerableInputs : { values: number[]; label: string; } ->{ values: [1, 2], label: "inputs" } : { values: number[]; label: string; } ->values : number[] +const a115 = { a: [1, 2], b: "inputs" }; +>a115 : { a: number[]; b: string; } +>{ a: [1, 2], b: "inputs" } : { a: number[]; b: string; } +>a : number[] >[1, 2] : number[] >1 : 1 >2 : 2 ->label : string +>b : string >"inputs" : "inputs" -const enumerable = Iterator.zipKeyed(enumerableInputs).toArray(); ->enumerable : Record[] ->Iterator.zipKeyed(enumerableInputs).toArray() : Record[] ->Iterator.zipKeyed(enumerableInputs).toArray : () => Record[] ->Iterator.zipKeyed(enumerableInputs) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a116 = Iterator.zipKeyed(a115).toArray(); +>a116 : Record[] +>Iterator.zipKeyed(a115).toArray() : Record[] +>Iterator.zipKeyed(a115).toArray : () => Record[] +>Iterator.zipKeyed(a115) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->enumerableInputs : { values: number[]; label: string; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a115 : { a: number[]; b: string; } >toArray : () => Record[] -// The array's length and methods are not enumerable own properties. -const arrayInputs = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); ->arrayInputs : Record[] +const a117 = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); +>a117 : Record[] >Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray() : Record[] >Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray : () => Record[] >Iterator.zipKeyed([[1, 2], ["a", "b"]]) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >[[1, 2], ["a", "b"]] : (string[] | number[])[] >[1, 2] : number[] >1 : 1 @@ -1780,160 +1771,269 @@ const arrayInputs = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); >"b" : "b" >toArray : () => Record[] -// The fallback must not claim that ignored properties exist on yielded objects. -const inheritedLabel: string = inherited[0].label; ->inheritedLabel : string ->inherited[0].label : unknown ->inherited[0] : Record ->inherited : Record[] +const a118: string = a108[0].b; +>a118 : string +>a108[0].b : unknown +>a108[0] : Record +>a108 : Record[] >0 : 0 ->label : unknown +>b : unknown -const nonEnumerableLabel: string = nonEnumerable[0].label; ->nonEnumerableLabel : string ->nonEnumerable[0].label : unknown ->nonEnumerable[0] : Record ->nonEnumerable : Record[] +const a119: string = a113[0].b; +>a119 : string +>a113[0].b : unknown +>a113[0] : Record +>a113 : Record[] >0 : 0 ->label : unknown - -// Precise record inference still handles symbol keys and padding. -declare const ownKey: unique symbol; ->ownKey : unique symbol - -const precise: { values: number; [ownKey]: string; }[] = Iterator.zipKeyed({ values: [1], [ownKey]: ["a"] }).toArray(); ->precise : { values: number; [ownKey]: string; }[] ->values : number ->[ownKey] : string ->ownKey : unique symbol ->Iterator.zipKeyed({ values: [1], [ownKey]: ["a"] }).toArray() : { values: number; [ownKey]: string; }[] ->Iterator.zipKeyed({ values: [1], [ownKey]: ["a"] }).toArray : () => { values: number; [ownKey]: string; }[] ->Iterator.zipKeyed({ values: [1], [ownKey]: ["a"] }) : IteratorObject<{ values: number; [ownKey]: string; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->{ values: [1], [ownKey]: ["a"] } : { values: number[]; [ownKey]: string[]; } ->values : number[] +>b : unknown + +declare const a120: unique symbol; +>a120 : unique symbol + +const a121: { a: number; [a120]: string; }[] = Iterator.zipKeyed({ a: [1], [a120]: ["a"] }).toArray(); +>a121 : { a: number; [a120]: string; }[] +>a : number +>[a120] : string +>a120 : unique symbol +>Iterator.zipKeyed({ a: [1], [a120]: ["a"] }).toArray() : ({ a: number; [a120]: string; } & {})[] +>Iterator.zipKeyed({ a: [1], [a120]: ["a"] }).toArray : () => ({ a: number; [a120]: string; } & {})[] +>Iterator.zipKeyed({ a: [1], [a120]: ["a"] }) : IteratorObject<{ a: number; [a120]: string; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1], [a120]: ["a"] } : { a: number[]; [a120]: string[]; } +>a : number[] >[1] : number[] >1 : 1 ->[ownKey] : string[] ->ownKey : unique symbol +>[a120] : string[] +>a120 : unique symbol >["a"] : string[] >"a" : "a" ->toArray : () => { values: number; [ownKey]: string; }[] - -const preciseLongest: { values: number | undefined; }[] = Iterator.zipKeyed({ values: [1] }, { mode: "longest" }).toArray(); ->preciseLongest : { values: number | undefined; }[] ->values : number | undefined ->Iterator.zipKeyed({ values: [1] }, { mode: "longest" }).toArray() : { values: number | undefined; }[] ->Iterator.zipKeyed({ values: [1] }, { mode: "longest" }).toArray : () => { values: number | undefined; }[] ->Iterator.zipKeyed({ values: [1] }, { mode: "longest" }) : IteratorObject<{ values: number | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->{ values: [1] } : { values: number[]; } ->values : number[] +>toArray : () => ({ a: number; [a120]: string; } & {})[] + +const a122: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1] }, { mode: "longest" }).toArray(); +>a122 : { a: number | undefined; }[] +>a : number | undefined +>Iterator.zipKeyed({ a: [1] }, { mode: "longest" }).toArray() : ({ a: number | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1] }, { mode: "longest" }).toArray : () => ({ a: number | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1] }, { mode: "longest" }) : IteratorObject<{ a: number | undefined; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1] } : { a: number[]; } +>a : number[] >[1] : number[] >1 : 1 >{ mode: "longest" } : { mode: "longest"; } >mode : "longest" >"longest" : "longest" ->toArray : () => { values: number | undefined; }[] - -const precisePadded: { values: number; }[] = Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: 0 } }).toArray(); ->precisePadded : { values: number; }[] ->values : number ->Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: 0 } }).toArray() : { values: number; }[] ->Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: 0 } }).toArray : () => { values: number; }[] ->Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: 0 } }) : IteratorObject<{ values: number; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->{ values: [1] } : { values: number[]; } ->values : number[] +>toArray : () => ({ a: number | undefined; } & {})[] + +const a123: { a: number; }[] = Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray(); +>a123 : { a: number; }[] +>a : number +>Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray() : ({ a: number; } & {})[] +>Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray : () => ({ a: number; } & {})[] +>Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: 0 } }) : IteratorObject<{ a: number; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1] } : { a: number[]; } +>a : number[] >[1] : number[] >1 : 1 ->{ mode: "longest", padding: { values: 0 } } : { mode: "longest"; padding: { values: number; }; } +>{ mode: "longest", padding: { a: 0 } } : { mode: "longest"; padding: { a: number; }; } >mode : "longest" >"longest" : "longest" ->padding : { values: number; } ->{ values: 0 } : { values: number; } ->values : number +>padding : { a: number; } +>{ a: 0 } : { a: number; } +>a : number >0 : 0 ->toArray : () => { values: number; }[] +>toArray : () => ({ a: number; } & {})[] + +declare const a124: object; +>a124 : object -const emptyOwnProperties: never[] = Iterator.zipKeyed({}).toArray(); ->emptyOwnProperties : never[] ->Iterator.zipKeyed({}).toArray() : never[] ->Iterator.zipKeyed({}).toArray : () => never[] ->Iterator.zipKeyed({}) : IteratorObject ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a125 = Iterator.zipKeyed(a124).toArray(); +>a125 : Record[] +>Iterator.zipKeyed(a124).toArray() : Record[] +>Iterator.zipKeyed(a124).toArray : () => Record[] +>Iterator.zipKeyed(a124) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->{} : {} ->toArray : () => never[] +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a124 : object +>toArray : () => Record[] + +const a126 = Iterator.zipKeyed(a124, { mode: "strict" }).toArray(); +>a126 : Record[] +>Iterator.zipKeyed(a124, { mode: "strict" }).toArray() : Record[] +>Iterator.zipKeyed(a124, { mode: "strict" }).toArray : () => Record[] +>Iterator.zipKeyed(a124, { mode: "strict" }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a124 : object +>{ mode: "strict" } : { mode: "strict"; } +>mode : "strict" +>"strict" : "strict" +>toArray : () => Record[] + +const a127 = Iterator.zipKeyed(a124, { mode: "longest" }).toArray(); +>a127 : Record[] +>Iterator.zipKeyed(a124, { mode: "longest" }).toArray() : Record[] +>Iterator.zipKeyed(a124, { mode: "longest" }).toArray : () => Record[] +>Iterator.zipKeyed(a124, { mode: "longest" }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a124 : object +>{ mode: "longest" } : { mode: "longest"; } +>mode : "longest" +>"longest" : "longest" +>toArray : () => Record[] + +const a128 = Iterator.zipKeyed(a124, { mode: "longest", padding: { a: 0 } }).toArray(); +>a128 : Record[] +>Iterator.zipKeyed(a124, { mode: "longest", padding: { a: 0 } }).toArray() : Record[] +>Iterator.zipKeyed(a124, { mode: "longest", padding: { a: 0 } }).toArray : () => Record[] +>Iterator.zipKeyed(a124, { mode: "longest", padding: { a: 0 } }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a124 : object +>{ mode: "longest", padding: { a: 0 } } : { mode: "longest"; padding: { a: number; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: number; } +>{ a: 0 } : { a: number; } +>a : number +>0 : 0 +>toArray : () => Record[] + +const a129: unknown = a125[0].a; +>a129 : unknown +>a125[0].a : unknown +>a125[0] : Record +>a125 : Record[] +>0 : 0 +>a : unknown + +const a130: unknown = a126[0].a; +>a130 : unknown +>a126[0].a : unknown +>a126[0] : Record +>a126 : Record[] +>0 : 0 +>a : unknown + +const a131: unknown = a127[0].a; +>a131 : unknown +>a127[0].a : unknown +>a127[0] : Record +>a127 : Record[] +>0 : 0 +>a : unknown + +const a132: unknown = a128[0].a; +>a132 : unknown +>a128[0].a : unknown +>a128[0] : Record +>a128 : Record[] +>0 : 0 +>a : unknown + +const a133: never[] = a125; +>a133 : never[] +>a125 : Record[] + +declare const a134: {}; +>a134 : {} + +const a135 = Iterator.zipKeyed(a134).toArray(); +>a135 : Record[] +>Iterator.zipKeyed(a134).toArray() : Record[] +>Iterator.zipKeyed(a134).toArray : () => Record[] +>Iterator.zipKeyed(a134) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a134 : {} +>toArray : () => Record[] + +const a136: unknown = a135[0].a; +>a136 : unknown +>a135[0].a : unknown +>a135[0] : Record +>a135 : Record[] +>0 : 0 +>a : unknown + +const a137: never[] = a135; +>a137 : never[] +>a135 : Record[] Iterator.zipKeyed(0); ->Iterator.zipKeyed(0) : IteratorObject ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed(0) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >0 : 0 Iterator.zipKeyed(null); ->Iterator.zipKeyed(null) : IteratorObject ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed(null) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } -Iterator.zipKeyed(instance, { mode: "invalid" }); ->Iterator.zipKeyed(instance, { mode: "invalid" }) : IteratorObject<{ values: number; label: never; describe: never; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +Iterator.zipKeyed(a107, { mode: "invalid" }); +>Iterator.zipKeyed(a107, { mode: "invalid" }) : IteratorObject<{ a: number; b: never; f: never; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->instance : InputsWithPrototypeMembers +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a107 : C1 >{ mode: "invalid" } : { mode: "invalid"; } >mode : "invalid" >"invalid" : "invalid" -Iterator.zipKeyed(instance, { mode: "shortest", padding: {} }); ->Iterator.zipKeyed(instance, { mode: "shortest", padding: {} }) : IteratorObject<{ values: number; label: never; describe: never; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +Iterator.zipKeyed(a107, { mode: "shortest", padding: {} }); +>Iterator.zipKeyed(a107, { mode: "shortest", padding: {} }) : IteratorObject<{ a: number; b: never; f: never; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->instance : InputsWithPrototypeMembers +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a107 : C1 >{ mode: "shortest", padding: {} } : { mode: "shortest"; padding: {}; } >mode : "shortest" >"shortest" : "shortest" >padding : {} >{} : {} -Iterator.zipKeyed(instance, { mode: "longest", padding: 0 }); ->Iterator.zipKeyed(instance, { mode: "longest", padding: 0 }) : IteratorObject<{ values: number; label: never; describe: never; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +Iterator.zipKeyed(a107, { mode: "longest", padding: 0 }); +>Iterator.zipKeyed(a107, { mode: "longest", padding: 0 }) : IteratorObject<{ a: number; b: never; f: never; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->instance : InputsWithPrototypeMembers +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a107 : C1 >{ mode: "longest", padding: 0 } : { mode: "longest"; padding: number; } >mode : "longest" >"longest" : "longest" >padding : number >0 : 0 -Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: "invalid" } }); ->Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: "invalid" } }) : IteratorObject<{ values: number; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: "invalid" } }); +>Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: "invalid" } }) : IteratorObject<{ a: number; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K] | undefined; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->{ values: [1] } : { values: number[]; } ->values : number[] +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1] } : { a: number[]; } +>a : number[] >[1] : number[] >1 : 1 ->{ mode: "longest", padding: { values: "invalid" } } : { mode: "longest"; padding: { values: string; }; } +>{ mode: "longest", padding: { a: "invalid" } } : { mode: "longest"; padding: { a: string; }; } >mode : "longest" >"longest" : "longest" ->padding : { values: string; } ->{ values: "invalid" } : { values: string; } ->values : string +>padding : { a: string; } +>{ a: "invalid" } : { a: string; } +>a : string >"invalid" : "invalid" diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).errors.txt b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).errors.txt index d9df07d45c33f..c2e81cfcba57c 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).errors.txt @@ -17,11 +17,11 @@ iteratorZip.ts(68,14): error TS2769: No overload matches this call. The last overload gave the following error. Argument of type 'number' is not assignable to parameter of type 'Iterable> & object'. Type 'number' is not assignable to type 'Iterable>'. -iteratorZip.ts(80,14): error TS2769: No overload matches this call. +iteratorZip.ts(78,14): error TS2769: No overload matches this call. The last overload gave the following error. Argument of type 'string' is not assignable to parameter of type 'Iterable> & object'. Type 'string' is not assignable to type 'Iterable>'. -iteratorZip.ts(81,14): error TS2769: No overload matches this call. +iteratorZip.ts(79,14): error TS2769: No overload matches this call. The last overload gave the following error. Argument of type 'string[]' is not assignable to parameter of type 'Iterable> & object'. Type 'string[]' is not assignable to type 'Iterable>'. @@ -30,7 +30,7 @@ iteratorZip.ts(81,14): error TS2769: No overload matches this call. Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. Type 'string' is not assignable to type 'IteratorInput'. -iteratorZip.ts(82,14): error TS2769: No overload matches this call. +iteratorZip.ts(80,14): error TS2769: No overload matches this call. The last overload gave the following error. Argument of type 'Set' is not assignable to parameter of type 'Iterable> & object'. Type 'Set' is not assignable to type 'Iterable>'. @@ -39,26 +39,26 @@ iteratorZip.ts(82,14): error TS2769: No overload matches this call. Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. Type 'string' is not assignable to type 'IteratorInput'. -iteratorZip.ts(83,19): error TS2769: No overload matches this call. +iteratorZip.ts(81,19): error TS2769: No overload matches this call. The last overload gave the following error. Argument of type '"ab"' is not assignable to parameter of type 'never'. -iteratorZip.ts(85,37): error TS2769: No overload matches this call. +iteratorZip.ts(83,37): error TS2769: No overload matches this call. The last overload gave the following error. Type 'string' is not assignable to type 'Iterable & object'. Type 'string' is not assignable to type 'Iterable'. -iteratorZip.ts(86,42): error TS2769: No overload matches this call. +iteratorZip.ts(84,42): error TS2769: No overload matches this call. The last overload gave the following error. Type 'string' is not assignable to type 'Iterable & object'. Type 'string' is not assignable to type 'object'. -iteratorZip.ts(87,19): error TS2769: No overload matches this call. +iteratorZip.ts(85,19): error TS2769: No overload matches this call. The last overload gave the following error. Argument of type '{}' is not assignable to parameter of type 'never'. -iteratorZip.ts(95,6): error TS2339: Property 'b' does not exist on type 'IteratorZipResult<{ a: number[]; } & {}, never, {}>'. -iteratorZip.ts(111,6): error TS2339: Property 'd' does not exist on type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator; readonly c?: Iterable | undefined; }, never, {}>'. -iteratorZip.ts(112,7): error TS2322: Type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator; readonly c?: Iterable | undefined; }, never, {}>[]' is not assignable to type '{ a: number; c: boolean; }[]'. - Type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator; readonly c?: Iterable | undefined; }, never, {}>' is not assignable to type '{ a: number; c: boolean; }'. - Property 'c' is optional in type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator; readonly c?: Iterable | undefined; }, never, {}>' but required in type '{ a: number; c: boolean; }'. -iteratorZip.ts(132,14): error TS2769: No overload matches this call. +iteratorZip.ts(93,8): error TS2339: Property 'b' does not exist on type '{ a: number; } & {}'. +iteratorZip.ts(109,8): error TS2339: Property 'd' does not exist on type '{ a: number; } & { b?: string; c?: IteratorZipValue | undefined, "c", never, {}>; }'. +iteratorZip.ts(110,7): error TS2322: Type '({ a: number; } & { b?: string; c?: IteratorZipValue | undefined, "c", never, {}>; })[]' is not assignable to type '{ a: number; c: boolean; }[]'. + Type '{ a: number; } & { b?: string; c?: IteratorZipValue | undefined, "c", never, {}>; }' is not assignable to type '{ a: number; c: boolean; }'. + Property 'c' is optional in type '{ a: number; } & { b?: string; c?: IteratorZipValue | undefined, "c", never, {}>; }' but required in type '{ a: number; c: boolean; }'. +iteratorZip.ts(130,14): error TS2769: No overload matches this call. The last overload gave the following error. Argument of type 'undefined[]' is not assignable to parameter of type 'Iterable> & object'. Type 'undefined[]' is not assignable to type 'Iterable>'. @@ -67,155 +67,159 @@ iteratorZip.ts(132,14): error TS2769: No overload matches this call. Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. Type 'undefined' is not assignable to type 'IteratorInput'. -iteratorZip.ts(150,7): error TS2322: Type '[number, ...(number | undefined)[]][]' is not assignable to type 'number[][]'. - Type '[number, ...(number | undefined)[]]' is not assignable to type 'number[]'. - Type 'number | undefined' is not assignable to type 'number'. +iteratorZip.ts(146,7): error TS2322: Type '[number, ...IteratorZipValue, number, undefined, [number]>[]][]' is not assignable to type 'number[][]'. + Type '[number, ...IteratorZipValue, number, undefined, [number]>[]]' is not assignable to type 'number[]'. + Type 'IteratorZipValue, number, undefined, [number]>' is not assignable to type 'number'. Type 'undefined' is not assignable to type 'number'. -iteratorZip.ts(155,7): error TS2322: Type 'IteratorZipResult<{ [x: string]: Iterable; } & {}, undefined, {}>[]' is not assignable to type 'Record[]'. - Type 'IteratorZipResult<{ [x: string]: Iterable; } & {}, undefined, {}>' is not assignable to type 'Record'. +iteratorZip.ts(151,7): error TS2322: Type '({ [x: string]: IteratorZipValue, string, undefined, {}>; } & {})[]' is not assignable to type 'Record[]'. + Type '{ [x: string]: IteratorZipValue, string, undefined, {}>; } & {}' is not assignable to type 'Record'. 'string' index signatures are incompatible. - Type 'number | undefined' is not assignable to type 'number'. + Type 'IteratorZipValue, string, undefined, {}>' is not assignable to type 'number'. Type 'undefined' is not assignable to type 'number'. -iteratorZip.ts(160,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record>[]' is not assignable to type '{ a: number; b: number; }[]'. - Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record>' is not assignable to type '{ a: number; b: number; }'. +iteratorZip.ts(156,7): error TS2322: Type '({ a: IteratorZipValue>; b: IteratorZipValue>; } & {})[]' is not assignable to type '{ a: number; b: number; }[]'. + Type '{ a: IteratorZipValue>; b: IteratorZipValue>; } & {}' is not assignable to type '{ a: number; b: number; }'. Types of property 'a' are incompatible. - Type 'number | undefined' is not assignable to type 'number'. + Type 'IteratorZipValue>' is not assignable to type 'number'. Type 'undefined' is not assignable to type 'number'. -iteratorZip.ts(169,7): error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. - Type '[number, string | undefined]' is not assignable to type '[number, string]'. +iteratorZip.ts(165,7): error TS2322: Type '[number, IteratorZipValue][]' is not assignable to type '[number, string][]'. + Type '[number, IteratorZipValue]' is not assignable to type '[number, string]'. Type at position 1 in source is not compatible with type at position 1 in target. - Type 'string | undefined' is not assignable to type 'string'. + Type 'IteratorZipValue' is not assignable to type 'string'. Type 'undefined' is not assignable to type 'string'. -iteratorZip.ts(172,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; }>[]' is not assignable to type '{ a: number; b: string; }[]'. - Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; b: string; }'. +iteratorZip.ts(168,7): error TS2322: Type '({ a: number; b: IteratorZipValue; } & {})[]' is not assignable to type '{ a: number; b: string; }[]'. + Type '{ a: number; b: IteratorZipValue; } & {}' is not assignable to type '{ a: number; b: string; }'. Types of property 'b' are incompatible. - Type 'string | undefined' is not assignable to type 'string'. + Type 'IteratorZipValue' is not assignable to type 'string'. Type 'undefined' is not assignable to type 'string'. -iteratorZip.ts(178,7): error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. - Type '[number, string | undefined]' is not assignable to type '[number, string]'. +iteratorZip.ts(174,7): error TS2322: Type '[number, IteratorZipValue][]' is not assignable to type '[number, string][]'. + Type '[number, IteratorZipValue]' is not assignable to type '[number, string]'. Type at position 1 in source is not compatible with type at position 1 in target. - Type 'string | undefined' is not assignable to type 'string'. + Type 'IteratorZipValue' is not assignable to type 'string'. Type 'undefined' is not assignable to type 'string'. -iteratorZip.ts(182,7): error TS2322: Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>[]' is not assignable to type 'number[][]'. +iteratorZip.ts(178,7): error TS2322: Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>[]' is not assignable to type 'number[][]'. Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>' is not assignable to type 'number[]'. - Type '[number, number | undefined]' is not assignable to type 'number[]'. - Type 'number | undefined' is not assignable to type 'number'. + Type '[number, IteratorZipValue, "1", undefined, [number]>]' is not assignable to type 'number[]'. + Type 'IteratorZipValue, "1", undefined, [number]>' is not assignable to type 'number'. Type 'undefined' is not assignable to type 'number'. -iteratorZip.ts(185,7): error TS2322: Type '(IteratorZipResult<{ a: Iterable; } & {}, undefined, { a: number; }> | IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>)[]' is not assignable to type '({ a: number; } | { b: string; })[]'. - Type 'IteratorZipResult<{ a: Iterable; } & {}, undefined, { a: number; }> | IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; } | { b: string; }'. - Type 'IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; } | { b: string; }'. - Type 'IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ b: string; }'. +iteratorZip.ts(181,7): error TS2322: Type '(({ a: number; } & {}) | ({ b: IteratorZipValue, "b", undefined, { a: number; }>; } & {}))[]' is not assignable to type '({ a: number; } | { b: string; })[]'. + Type '({ a: number; } & {}) | ({ b: IteratorZipValue, "b", undefined, { a: number; }>; } & {})' is not assignable to type '{ a: number; } | { b: string; }'. + Type '{ b: IteratorZipValue, "b", undefined, { a: number; }>; } & {}' is not assignable to type '{ a: number; } | { b: string; }'. + Type '{ b: IteratorZipValue, "b", undefined, { a: number; }>; } & {}' is not assignable to type '{ b: string; }'. Types of property 'b' are incompatible. - Type 'string | undefined' is not assignable to type 'string'. + Type 'IteratorZipValue, "b", undefined, { a: number; }>' is not assignable to type 'string'. Type 'undefined' is not assignable to type 'string'. -iteratorZip.ts(189,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; } | { b: string; }>[]' is not assignable to type '{ a: number; b: string; }[]'. - Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; } | { b: string; }>' is not assignable to type '{ a: number; b: string; }'. +iteratorZip.ts(185,7): error TS2322: Type '({ a: IteratorZipValue; b: IteratorZipValue; } & {})[]' is not assignable to type '{ a: number; b: string; }[]'. + Type '{ a: IteratorZipValue; b: IteratorZipValue; } & {}' is not assignable to type '{ a: number; b: string; }'. Types of property 'a' are incompatible. - Type 'number | undefined' is not assignable to type 'number'. + Type 'IteratorZipValue' is not assignable to type 'number'. Type 'undefined' is not assignable to type 'number'. -iteratorZip.ts(192,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, { a: undefined; b: number; }>[]' is not assignable to type '{ a: number; b: number; }[]'. - Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, { a: undefined; b: number; }>' is not assignable to type '{ a: number; b: number; }'. +iteratorZip.ts(188,7): error TS2322: Type '({ a: IteratorZipValue; b: number; } & {})[]' is not assignable to type '{ a: number; b: number; }[]'. + Type '{ a: IteratorZipValue; b: number; } & {}' is not assignable to type '{ a: number; b: number; }'. Types of property 'a' are incompatible. - Type 'number | undefined' is not assignable to type 'number'. + Type 'IteratorZipValue' is not assignable to type 'number'. Type 'undefined' is not assignable to type 'number'. -iteratorZip.ts(196,7): error TS2322: Type 'IteratorZipResult<{ [x: `a${string}`]: Iterable; } & {}, undefined, {}>[]' is not assignable to type '{ [x: `a${string}`]: number; }[]'. - Type 'IteratorZipResult<{ [x: `a${string}`]: Iterable; } & {}, undefined, {}>' is not assignable to type '{ [x: `a${string}`]: number; }'. +iteratorZip.ts(192,7): error TS2322: Type '({ [x: `a${string}`]: IteratorZipValue, `a${string}`, undefined, {}>; } & {})[]' is not assignable to type '{ [x: `a${string}`]: number; }[]'. + Type '{ [x: `a${string}`]: IteratorZipValue, `a${string}`, undefined, {}>; } & {}' is not assignable to type '{ [x: `a${string}`]: number; }'. '`a${string}`' index signatures are incompatible. - Type 'number | undefined' is not assignable to type 'number'. + Type 'IteratorZipValue, `a${string}`, undefined, {}>' is not assignable to type 'number'. Type 'undefined' is not assignable to type 'number'. -iteratorZip.ts(204,7): error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record & { a: number; }>[]' is not assignable to type '{ a: number; b: number; }[]'. - Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record & { a: number; }>' is not assignable to type '{ a: number; b: number; }'. +iteratorZip.ts(200,7): error TS2322: Type '({ a: number; b: IteratorZipValue & { a: number; }>; } & {})[]' is not assignable to type '{ a: number; b: number; }[]'. + Type '{ a: number; b: IteratorZipValue & { a: number; }>; } & {}' is not assignable to type '{ a: number; b: number; }'. Types of property 'b' are incompatible. - Type 'number | undefined' is not assignable to type 'number'. + Type 'IteratorZipValue & { a: number; }>' is not assignable to type 'number'. Type 'undefined' is not assignable to type 'number'. -iteratorZip.ts(209,7): error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. - Type '[number, string | undefined]' is not assignable to type '[number, string]'. +iteratorZip.ts(205,7): error TS2322: Type '[number, IteratorZipValue][]' is not assignable to type '[number, string][]'. + Type '[number, IteratorZipValue]' is not assignable to type '[number, string]'. Type at position 1 in source is not compatible with type at position 1 in target. - Type 'string | undefined' is not assignable to type 'string'. + Type 'IteratorZipValue' is not assignable to type 'string'. Type 'undefined' is not assignable to type 'string'. -iteratorZip.ts(248,7): error TS2322: Type 'unknown' is not assignable to type 'string'. -iteratorZip.ts(249,7): error TS2322: Type 'unknown' is not assignable to type 'string'. -iteratorZip.ts(258,19): error TS2769: No overload matches this call. +iteratorZip.ts(238,7): error TS2322: Type 'unknown' is not assignable to type 'string'. +iteratorZip.ts(239,7): error TS2322: Type 'unknown' is not assignable to type 'string'. +iteratorZip.ts(255,7): error TS2322: Type 'Record[]' is not assignable to type 'never[]'. + Type 'Record' is not assignable to type 'never'. +iteratorZip.ts(260,7): error TS2322: Type 'Record[]' is not assignable to type 'never[]'. + Type 'Record' is not assignable to type 'never'. +iteratorZip.ts(262,19): error TS2769: No overload matches this call. The last overload gave the following error. Argument of type '0' is not assignable to parameter of type 'never'. -iteratorZip.ts(259,19): error TS2769: No overload matches this call. +iteratorZip.ts(263,19): error TS2769: No overload matches this call. The last overload gave the following error. Argument of type 'null' is not assignable to parameter of type 'never'. -iteratorZip.ts(260,31): error TS2769: No overload matches this call. +iteratorZip.ts(264,27): error TS2769: No overload matches this call. The last overload gave the following error. Type '"invalid"' is not assignable to type '"longest" | "shortest" | "strict" | undefined'. -iteratorZip.ts(261,49): error TS2769: No overload matches this call. +iteratorZip.ts(265,45): error TS2769: No overload matches this call. The last overload gave the following error. Object literal may only specify known properties, and 'padding' does not exist in type 'IteratorZipShortestOptions'. -iteratorZip.ts(262,48): error TS2769: No overload matches this call. +iteratorZip.ts(266,44): error TS2769: No overload matches this call. The last overload gave the following error. Type 'number' is not assignable to type 'object'. -iteratorZip.ts(263,19): error TS2769: No overload matches this call. +iteratorZip.ts(267,19): error TS2769: No overload matches this call. The last overload gave the following error. - Argument of type '{ values: number[]; }' is not assignable to parameter of type 'never'. + Argument of type '{ a: number[]; }' is not assignable to parameter of type 'never'. -==== iteratorZip.ts (36 errors) ==== - declare const key: unique symbol; +==== iteratorZip.ts (38 errors) ==== + declare const a1: unique symbol; - const tuples: [number, string][] = Iterator.zip([ + const a2: [number, string][] = Iterator.zip([ [1, 2], new Set(["a", "b"]), ] as const).toArray(); - tuples[0][0] = 2; + a2[0][0] = 2; - const shortestTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray(); - const strictTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray(); - const longestTuplesWithPadding: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray(); - const longestTuplesWithoutPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray(); - const longestTuplesWithPartialPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray(); + const a3: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray(); + const a4: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray(); + const a5: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray(); + const a6: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray(); + const a7: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray(); - declare const maybeLongestOptions: { mode: "shortest"; } | { mode: "longest"; }; - const maybeLongestTuples: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray(); + declare const a8: { mode: "shortest"; } | { mode: "longest"; }; + const a9: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, a8).toArray(); - const empty: never[] = Iterator.zip([]).toArray(); - const emptyLongest: never[] = Iterator.zip([], { mode: "longest" }).toArray(); + const a10: never[] = Iterator.zip([]).toArray(); + const a11: never[] = Iterator.zip([], { mode: "longest" }).toArray(); - declare const iterables: Iterable>; - const arrays: number[][] = Iterator.zip(iterables).toArray(); - const longestArrays: (number | undefined)[][] = Iterator.zip(iterables, { mode: "longest" }).toArray(); - const maybeLongestArrays: (number | undefined)[][] = Iterator.zip(iterables, maybeLongestOptions).toArray(); + declare const a12: Iterable>; + const a13: number[][] = Iterator.zip(a12).toArray(); + const a14: (number | undefined)[][] = Iterator.zip(a12, { mode: "longest" }).toArray(); + const a15: (number | undefined)[][] = Iterator.zip(a12, a8).toArray(); - declare const iterableArray: Iterable[]; - const longestArrayWithPadding: (number | undefined)[][] = Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray(); + declare const a16: Iterable[]; + const a17: (number | undefined)[][] = Iterator.zip(a16, { mode: "longest", padding: [] }).toArray(); - const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ + const a18: { a: number; b: string; [a1]: boolean; }[] = Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), - [key]: [true, false], + [a1]: [true, false], } as const).toArray(); - objects[0].a = 2; + a18[0].a = 2; - const longestObjectsWithPadding: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { + const a19: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" }, }).toArray(); - const longestObjectsWithoutPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { + const a20: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", }).toArray(); - const longestObjectsWithPartialPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { + const a21: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" }, }).toArray(); - const maybeLongestObjects: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray(); + const a22: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, a8).toArray(); - interface Inputs { + interface I1 { a: Iterable; b: Iterator; } - declare const inputs: Inputs; - const rows: { a: number; b: string; }[] = Iterator.zipKeyed(inputs).toArray(); + declare const a23: I1; + const a24: { a: number; b: string; }[] = Iterator.zipKeyed(a23).toArray(); Iterator.zip([[1]], { mode: "invalid" }); ~~~~ @@ -254,13 +258,11 @@ iteratorZip.ts(263,19): error TS2769: No overload matches this call. Iterator.zipKeyed({ a: 0 }); - const emptyKeyed: never[] = Iterator.zipKeyed({}).toArray(); - const emptyKeyedLongest: never[] = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); + const a25: Record[] = Iterator.zipKeyed({}).toArray(); + const a26: Record[] = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); - declare const unionInputs: { a: Iterable; } | { b: Iterator; }; - const unionRows: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(unionInputs).toArray(); - - // Inputs + declare const a27: { a: Iterable; } | { b: Iterator; }; + const a28: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(a27).toArray(); Iterator.zip("ab"); ~~~~ @@ -321,54 +323,54 @@ iteratorZip.ts(263,19): error TS2769: No overload matches this call. !!! error TS2769: Argument of type '{}' is not assignable to parameter of type 'never'. !!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. - const a: [string][] = Iterator.zip([new String("ab")]).toArray(); - const b: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); - const c: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); + const a29: [string][] = Iterator.zip([new String("ab")]).toArray(); + const a30: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); + const a31: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); - const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); - const e: { a: number; }[] = d; - d[0].b; - ~ -!!! error TS2339: Property 'b' does not exist on type 'IteratorZipResult<{ a: number[]; } & {}, never, {}>'. - const f: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); - const g: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); + const a32 = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); + const a33: { a: number; }[] = a32; + a32[0].b; + ~ +!!! error TS2339: Property 'b' does not exist on type '{ a: number; } & {}'. + const a34: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); + const a35: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); - interface I { + interface I2 { readonly a: Iterable; readonly b?: Iterator; readonly c: Iterable | undefined; readonly d?: undefined; } - declare const h: I; - const i = Iterator.zipKeyed(h).toArray(); - const j: { a: number; b?: string; c?: boolean; }[] = i; - i[0].a = 2; - i[0].b = "a"; - i[0].c = true; - i[0].d; - ~ -!!! error TS2339: Property 'd' does not exist on type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator; readonly c?: Iterable | undefined; }, never, {}>'. - const k: { a: number; c: boolean; }[] = i; - ~ -!!! error TS2322: Type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator; readonly c?: Iterable | undefined; }, never, {}>[]' is not assignable to type '{ a: number; c: boolean; }[]'. -!!! error TS2322: Type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator; readonly c?: Iterable | undefined; }, never, {}>' is not assignable to type '{ a: number; c: boolean; }'. -!!! error TS2322: Property 'c' is optional in type 'IteratorZipResult<{ readonly a: Iterable; } & { readonly b?: Iterator; readonly c?: Iterable | undefined; }, never, {}>' but required in type '{ a: number; c: boolean; }'. - const l: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); - - declare const m: { a: Iterable; } | { b: Iterator; }; - const n: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(m).toArray(); - declare const o: { a: Iterable; } | { b: number; }; - Iterator.zipKeyed(o); - Iterator.zipKeyed(o, { mode: "longest" }); - Iterator.zipKeyed(o, { mode: "longest", padding: {} }); - declare const p: { a?: Iterable; } | { b: string; }; - Iterator.zipKeyed(p); - declare const q: { a: Iterable; } | { b: undefined; }; - const r: { a: number; }[] = Iterator.zipKeyed(q).toArray(); - - declare const s: unique symbol; - declare const t: { a: Iterable; [s]?: Iterable; }; - const u: { a: number; [s]?: string; }[] = Iterator.zipKeyed(t).toArray(); + declare const a36: I2; + const a37 = Iterator.zipKeyed(a36).toArray(); + const a38: { a: number; b?: string; c?: boolean; }[] = a37; + a37[0].a = 2; + a37[0].b = "a"; + a37[0].c = true; + a37[0].d; + ~ +!!! error TS2339: Property 'd' does not exist on type '{ a: number; } & { b?: string; c?: IteratorZipValue | undefined, "c", never, {}>; }'. + const a39: { a: number; c: boolean; }[] = a37; + ~~~ +!!! error TS2322: Type '({ a: number; } & { b?: string; c?: IteratorZipValue | undefined, "c", never, {}>; })[]' is not assignable to type '{ a: number; c: boolean; }[]'. +!!! error TS2322: Type '{ a: number; } & { b?: string; c?: IteratorZipValue | undefined, "c", never, {}>; }' is not assignable to type '{ a: number; c: boolean; }'. +!!! error TS2322: Property 'c' is optional in type '{ a: number; } & { b?: string; c?: IteratorZipValue | undefined, "c", never, {}>; }' but required in type '{ a: number; c: boolean; }'. + const a40: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(a36, { mode: "longest" }).toArray(); + + declare const a41: { a: Iterable; } | { b: Iterator; }; + const a42: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(a41).toArray(); + declare const a43: { a: Iterable; } | { b: number; }; + Iterator.zipKeyed(a43); + Iterator.zipKeyed(a43, { mode: "longest" }); + Iterator.zipKeyed(a43, { mode: "longest", padding: {} }); + declare const a44: { a?: Iterable; } | { b: string; }; + Iterator.zipKeyed(a44); + declare const a45: { a: Iterable; } | { b: undefined; }; + const a46: { a: number; }[] = Iterator.zipKeyed(a45).toArray(); + + declare const a47: unique symbol; + declare const a48: { a: Iterable; [a47]?: Iterable; }; + const a49: { a: number; [a47]?: string; }[] = Iterator.zipKeyed(a48).toArray(); Iterator.zipKeyed({ a: [1], b: null }); Iterator.zipKeyed({ a: [1], b: false }); @@ -385,10 +387,10 @@ iteratorZip.ts(263,19): error TS2769: No overload matches this call. !!! error TS2769: Type 'undefined' is not assignable to type 'IteratorInput'. !!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. - declare const v: { a?: undefined; }; - const w: never[] = Iterator.zipKeyed(v).toArray(); - const x: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); - const y: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); + declare const a50: { a?: undefined; }; + const a51: never[] = Iterator.zipKeyed(a50).toArray(); + const a52: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); + const a53: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); function f1(a: Iterable) { const b: { a: T; }[] = Iterator.zipKeyed({ a }).toArray(); @@ -396,201 +398,213 @@ iteratorZip.ts(263,19): error TS2769: No overload matches this call. return { b, c }; } - // Padding - - const paddingA: [Iterable, ...Iterable[]] = [[1, 2], [3]]; - const paddingB = Iterator.zip(paddingA, { mode: "longest", padding: [0] }).toArray(); - const paddingC: (number | undefined)[][] = paddingB; - const paddingD: number[][] = paddingB; - ~~~~~~~~ -!!! error TS2322: Type '[number, ...(number | undefined)[]][]' is not assignable to type 'number[][]'. -!!! error TS2322: Type '[number, ...(number | undefined)[]]' is not assignable to type 'number[]'. -!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. + const a54: [Iterable, ...Iterable[]] = [[1, 2], [3]]; + const a55 = Iterator.zip(a54, { mode: "longest", padding: [0] }).toArray(); + const a56: (number | undefined)[][] = a55; + const a57: number[][] = a55; + ~~~ +!!! error TS2322: Type '[number, ...IteratorZipValue, number, undefined, [number]>[]][]' is not assignable to type 'number[][]'. +!!! error TS2322: Type '[number, ...IteratorZipValue, number, undefined, [number]>[]]' is not assignable to type 'number[]'. +!!! error TS2322: Type 'IteratorZipValue, number, undefined, [number]>' is not assignable to type 'number'. !!! error TS2322: Type 'undefined' is not assignable to type 'number'. - const paddingE: Record> = { a: [1], b: [2, 3] }; - const paddingF = Iterator.zipKeyed(paddingE, { mode: "longest", padding: {} }).toArray(); - const paddingG: Record[] = paddingF; - const paddingH: Record[] = paddingF; - ~~~~~~~~ -!!! error TS2322: Type 'IteratorZipResult<{ [x: string]: Iterable; } & {}, undefined, {}>[]' is not assignable to type 'Record[]'. -!!! error TS2322: Type 'IteratorZipResult<{ [x: string]: Iterable; } & {}, undefined, {}>' is not assignable to type 'Record'. + const a58: Record> = { a: [1], b: [2, 3] }; + const a59 = Iterator.zipKeyed(a58, { mode: "longest", padding: {} }).toArray(); + const a60: Record[] = a59; + const a61: Record[] = a59; + ~~~ +!!! error TS2322: Type '({ [x: string]: IteratorZipValue, string, undefined, {}>; } & {})[]' is not assignable to type 'Record[]'. +!!! error TS2322: Type '{ [x: string]: IteratorZipValue, string, undefined, {}>; } & {}' is not assignable to type 'Record'. !!! error TS2322: 'string' index signatures are incompatible. -!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'IteratorZipValue, string, undefined, {}>' is not assignable to type 'number'. !!! error TS2322: Type 'undefined' is not assignable to type 'number'. - declare const paddingI: Record; - const paddingJ = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: paddingI }).toArray(); - const paddingK: { a: number | undefined; b: number | undefined; }[] = paddingJ; - const paddingL: { a: number; b: number; }[] = paddingJ; - ~~~~~~~~ -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record>[]' is not assignable to type '{ a: number; b: number; }[]'. -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record>' is not assignable to type '{ a: number; b: number; }'. + declare const a62: Record; + const a63 = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a62 }).toArray(); + const a64: { a: number | undefined; b: number | undefined; }[] = a63; + const a65: { a: number; b: number; }[] = a63; + ~~~ +!!! error TS2322: Type '({ a: IteratorZipValue>; b: IteratorZipValue>; } & {})[]' is not assignable to type '{ a: number; b: number; }[]'. +!!! error TS2322: Type '{ a: IteratorZipValue>; b: IteratorZipValue>; } & {}' is not assignable to type '{ a: number; b: number; }'. !!! error TS2322: Types of property 'a' are incompatible. -!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'IteratorZipValue>' is not assignable to type 'number'. !!! error TS2322: Type 'undefined' is not assignable to type 'number'. - const paddingM = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); - const paddingN: [number, string][] = paddingM; - const paddingO = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); - const paddingP: { a: number; b: string; }[] = paddingO; - - const paddingQ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); - const paddingR: [number | undefined, string | undefined][] = paddingQ; - const paddingS: [number, string][] = paddingQ; - ~~~~~~~~ -!!! error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. -!!! error TS2322: Type '[number, string | undefined]' is not assignable to type '[number, string]'. + const a66 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); + const a67: [number, string][] = a66; + const a68 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); + const a69: { a: number; b: string; }[] = a68; + + const a70 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); + const a71: [number | undefined, string | undefined][] = a70; + const a72: [number, string][] = a70; + ~~~ +!!! error TS2322: Type '[number, IteratorZipValue][]' is not assignable to type '[number, string][]'. +!!! error TS2322: Type '[number, IteratorZipValue]' is not assignable to type '[number, string]'. !!! error TS2322: Type at position 1 in source is not compatible with type at position 1 in target. -!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. +!!! error TS2322: Type 'IteratorZipValue' is not assignable to type 'string'. !!! error TS2322: Type 'undefined' is not assignable to type 'string'. - const paddingT = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); - const paddingU: { a: number | undefined; b: string | undefined; }[] = paddingT; - const paddingV: { a: number; b: string; }[] = paddingT; - ~~~~~~~~ -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; }>[]' is not assignable to type '{ a: number; b: string; }[]'. -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; b: string; }'. + const a73 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); + const a74: { a: number | undefined; b: string | undefined; }[] = a73; + const a75: { a: number; b: string; }[] = a73; + ~~~ +!!! error TS2322: Type '({ a: number; b: IteratorZipValue; } & {})[]' is not assignable to type '{ a: number; b: string; }[]'. +!!! error TS2322: Type '{ a: number; b: IteratorZipValue; } & {}' is not assignable to type '{ a: number; b: string; }'. !!! error TS2322: Types of property 'b' are incompatible. -!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. +!!! error TS2322: Type 'IteratorZipValue' is not assignable to type 'string'. !!! error TS2322: Type 'undefined' is not assignable to type 'string'. - declare const paddingW: readonly [number, string]; - const paddingX: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingW }).toArray(); - declare const paddingY: [number, string?]; - const paddingZ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY }).toArray(); - const paddingA1: [number, string][] = paddingZ; - ~~~~~~~~~ -!!! error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. -!!! error TS2322: Type '[number, string | undefined]' is not assignable to type '[number, string]'. + declare const a76: readonly [number, string]; + const a77: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a76 }).toArray(); + declare const a78: [number, string?]; + const a79 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a78 }).toArray(); + const a80: [number, string][] = a79; + ~~~ +!!! error TS2322: Type '[number, IteratorZipValue][]' is not assignable to type '[number, string][]'. +!!! error TS2322: Type '[number, IteratorZipValue]' is not assignable to type '[number, string]'. !!! error TS2322: Type at position 1 in source is not compatible with type at position 1 in target. -!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. +!!! error TS2322: Type 'IteratorZipValue' is not assignable to type 'string'. !!! error TS2322: Type 'undefined' is not assignable to type 'string'. - declare const paddingB1: [Iterable] | [Iterable, Iterable]; - const paddingC1 = Iterator.zip(paddingB1, { mode: "longest", padding: [0] }).toArray(); - const paddingD1: number[][] = paddingC1; - ~~~~~~~~~ + declare const a81: [Iterable] | [Iterable, Iterable]; + const a82 = Iterator.zip(a81, { mode: "longest", padding: [0] }).toArray(); + const a83: number[][] = a82; + ~~~ !!! error TS2322: Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>[]' is not assignable to type 'number[][]'. !!! error TS2322: Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>' is not assignable to type 'number[]'. -!!! error TS2322: Type '[number, number | undefined]' is not assignable to type 'number[]'. -!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type '[number, IteratorZipValue, "1", undefined, [number]>]' is not assignable to type 'number[]'. +!!! error TS2322: Type 'IteratorZipValue, "1", undefined, [number]>' is not assignable to type 'number'. !!! error TS2322: Type 'undefined' is not assignable to type 'number'. - declare const paddingE1: { a: Iterable; } | { b: Iterable; }; - const paddingF1 = Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: 0 } }).toArray(); - const paddingG1: ({ a: number; } | { b: string; })[] = paddingF1; - ~~~~~~~~~ -!!! error TS2322: Type '(IteratorZipResult<{ a: Iterable; } & {}, undefined, { a: number; }> | IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>)[]' is not assignable to type '({ a: number; } | { b: string; })[]'. -!!! error TS2322: Type 'IteratorZipResult<{ a: Iterable; } & {}, undefined, { a: number; }> | IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; } | { b: string; }'. -!!! error TS2322: Type 'IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ a: number; } | { b: string; }'. -!!! error TS2322: Type 'IteratorZipResult<{ b: Iterable; } & {}, undefined, { a: number; }>' is not assignable to type '{ b: string; }'. + declare const a84: { a: Iterable; } | { b: Iterable; }; + const a85 = Iterator.zipKeyed(a84, { mode: "longest", padding: { a: 0 } }).toArray(); + const a86: ({ a: number; } | { b: string; })[] = a85; + ~~~ +!!! error TS2322: Type '(({ a: number; } & {}) | ({ b: IteratorZipValue, "b", undefined, { a: number; }>; } & {}))[]' is not assignable to type '({ a: number; } | { b: string; })[]'. +!!! error TS2322: Type '({ a: number; } & {}) | ({ b: IteratorZipValue, "b", undefined, { a: number; }>; } & {})' is not assignable to type '{ a: number; } | { b: string; }'. +!!! error TS2322: Type '{ b: IteratorZipValue, "b", undefined, { a: number; }>; } & {}' is not assignable to type '{ a: number; } | { b: string; }'. +!!! error TS2322: Type '{ b: IteratorZipValue, "b", undefined, { a: number; }>; } & {}' is not assignable to type '{ b: string; }'. !!! error TS2322: Types of property 'b' are incompatible. -!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. +!!! error TS2322: Type 'IteratorZipValue, "b", undefined, { a: number; }>' is not assignable to type 'string'. !!! error TS2322: Type 'undefined' is not assignable to type 'string'. - declare const paddingH1: { a: number; } | { b: string; }; - const paddingI1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: paddingH1 }).toArray(); - const paddingJ1: { a: number; b: string; }[] = paddingI1; - ~~~~~~~~~ -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; } | { b: string; }>[]' is not assignable to type '{ a: number; b: string; }[]'. -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: string[]; } & {}, undefined, { a: number; } | { b: string; }>' is not assignable to type '{ a: number; b: string; }'. + declare const a87: { a: number; } | { b: string; }; + const a88 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: a87 }).toArray(); + const a89: { a: number; b: string; }[] = a88; + ~~~ +!!! error TS2322: Type '({ a: IteratorZipValue; b: IteratorZipValue; } & {})[]' is not assignable to type '{ a: number; b: string; }[]'. +!!! error TS2322: Type '{ a: IteratorZipValue; b: IteratorZipValue; } & {}' is not assignable to type '{ a: number; b: string; }'. !!! error TS2322: Types of property 'a' are incompatible. -!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'IteratorZipValue' is not assignable to type 'number'. !!! error TS2322: Type 'undefined' is not assignable to type 'number'. - const paddingK1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); - const paddingL1: { a: number; b: number; }[] = paddingK1; - ~~~~~~~~~ -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, { a: undefined; b: number; }>[]' is not assignable to type '{ a: number; b: number; }[]'. -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, { a: undefined; b: number; }>' is not assignable to type '{ a: number; b: number; }'. + const a90 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); + const a91: { a: number; b: number; }[] = a90; + ~~~ +!!! error TS2322: Type '({ a: IteratorZipValue; b: number; } & {})[]' is not assignable to type '{ a: number; b: number; }[]'. +!!! error TS2322: Type '{ a: IteratorZipValue; b: number; } & {}' is not assignable to type '{ a: number; b: number; }'. !!! error TS2322: Types of property 'a' are incompatible. -!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'IteratorZipValue' is not assignable to type 'number'. !!! error TS2322: Type 'undefined' is not assignable to type 'number'. - declare const paddingM1: { [K in `a${string}`]: Iterable; }; - const paddingN1 = Iterator.zipKeyed(paddingM1, { mode: "longest", padding: {} }).toArray(); - const paddingO1: { [K in `a${string}`]: number; }[] = paddingN1; - ~~~~~~~~~ -!!! error TS2322: Type 'IteratorZipResult<{ [x: `a${string}`]: Iterable; } & {}, undefined, {}>[]' is not assignable to type '{ [x: `a${string}`]: number; }[]'. -!!! error TS2322: Type 'IteratorZipResult<{ [x: `a${string}`]: Iterable; } & {}, undefined, {}>' is not assignable to type '{ [x: `a${string}`]: number; }'. + declare const a92: { [K in `a${string}`]: Iterable; }; + const a93 = Iterator.zipKeyed(a92, { mode: "longest", padding: {} }).toArray(); + const a94: { [K in `a${string}`]: number; }[] = a93; + ~~~ +!!! error TS2322: Type '({ [x: `a${string}`]: IteratorZipValue, `a${string}`, undefined, {}>; } & {})[]' is not assignable to type '{ [x: `a${string}`]: number; }[]'. +!!! error TS2322: Type '{ [x: `a${string}`]: IteratorZipValue, `a${string}`, undefined, {}>; } & {}' is not assignable to type '{ [x: `a${string}`]: number; }'. !!! error TS2322: '`a${string}`' index signatures are incompatible. -!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'IteratorZipValue, `a${string}`, undefined, {}>' is not assignable to type 'number'. !!! error TS2322: Type 'undefined' is not assignable to type 'number'. - declare const paddingP1: unique symbol; - const paddingQ1: { [paddingP1]: number; }[] = Iterator.zipKeyed({ [paddingP1]: [1] }, { mode: "longest", padding: { [paddingP1]: 0 } }).toArray(); + declare const a95: unique symbol; + const a96: { [a95]: number; }[] = Iterator.zipKeyed({ [a95]: [1] }, { mode: "longest", padding: { [a95]: 0 } }).toArray(); - declare const paddingR1: Record & { a: number; }; - const paddingS1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: paddingR1 }).toArray(); - const paddingT1: { a: number; b: number | undefined; }[] = paddingS1; - const paddingU1: { a: number; b: number; }[] = paddingS1; - ~~~~~~~~~ -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record & { a: number; }>[]' is not assignable to type '{ a: number; b: number; }[]'. -!!! error TS2322: Type 'IteratorZipResult<{ a: number[]; b: number[]; } & {}, undefined, Record & { a: number; }>' is not assignable to type '{ a: number; b: number; }'. + declare const a97: Record & { a: number; }; + const a98 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: a97 }).toArray(); + const a99: { a: number; b: number | undefined; }[] = a98; + const a100: { a: number; b: number; }[] = a98; + ~~~~ +!!! error TS2322: Type '({ a: number; b: IteratorZipValue & { a: number; }>; } & {})[]' is not assignable to type '{ a: number; b: number; }[]'. +!!! error TS2322: Type '{ a: number; b: IteratorZipValue & { a: number; }>; } & {}' is not assignable to type '{ a: number; b: number; }'. !!! error TS2322: Types of property 'b' are incompatible. -!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'. +!!! error TS2322: Type 'IteratorZipValue & { a: number; }>' is not assignable to type 'number'. !!! error TS2322: Type 'undefined' is not assignable to type 'number'. - declare const paddingV1: [number] | [number, string]; - const paddingW1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingV1 }).toArray(); - const paddingX1: [number, string | undefined][] = paddingW1; - const paddingY1: [number, string][] = paddingW1; - ~~~~~~~~~ -!!! error TS2322: Type '[number, string | undefined][]' is not assignable to type '[number, string][]'. -!!! error TS2322: Type '[number, string | undefined]' is not assignable to type '[number, string]'. + declare const a101: [number] | [number, string]; + const a102 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a101 }).toArray(); + const a103: [number, string | undefined][] = a102; + const a104: [number, string][] = a102; + ~~~~ +!!! error TS2322: Type '[number, IteratorZipValue][]' is not assignable to type '[number, string][]'. +!!! error TS2322: Type '[number, IteratorZipValue]' is not assignable to type '[number, string]'. !!! error TS2322: Type at position 1 in source is not compatible with type at position 1 in target. -!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. +!!! error TS2322: Type 'IteratorZipValue' is not assignable to type 'string'. !!! error TS2322: Type 'undefined' is not assignable to type 'string'. - const paddingZ1: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); - const paddingA2: { a: number | undefined; b: number; }[] = paddingK1; - - // Own properties + const a105: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); + const a106: { a: number | undefined; b: number; }[] = a90; - class InputsWithPrototypeMembers { - values = [1, 2]; + class C1 { + a = [1, 2]; - get label() { + get b() { return "inputs"; } - describe() { - return this.label; + f() { + return this.b; } } - const instance = new InputsWithPrototypeMembers(); - const inherited = Iterator.zipKeyed(instance).toArray(); - const inheritedStrict = Iterator.zipKeyed(instance, { mode: "strict" }).toArray(); - const inheritedLongest = Iterator.zipKeyed(instance, { mode: "longest" }).toArray(); - const inheritedPadded = Iterator.zipKeyed(instance, { mode: "longest", padding: { values: 0 } }).toArray(); + const a107 = new C1(); + const a108 = Iterator.zipKeyed(a107).toArray(); + const a109 = Iterator.zipKeyed(a107, { mode: "strict" }).toArray(); + const a110 = Iterator.zipKeyed(a107, { mode: "longest" }).toArray(); + const a111 = Iterator.zipKeyed(a107, { mode: "longest", padding: { a: 0 } }).toArray(); - const hiddenInputs = { values: [1, 2], label: "inputs" }; - Object.defineProperty(hiddenInputs, "label", { enumerable: false }); - const nonEnumerable = Iterator.zipKeyed(hiddenInputs).toArray(); - const nonEnumerablePadded = Iterator.zipKeyed(hiddenInputs, { mode: "longest", padding: { values: 0 } }).toArray(); + const a112 = { a: [1, 2], b: "inputs" }; + Object.defineProperty(a112, "b", { enumerable: false }); + const a113 = Iterator.zipKeyed(a112).toArray(); + const a114 = Iterator.zipKeyed(a112, { mode: "longest", padding: { a: 0 } }).toArray(); - // The same static shape can have an enumerable non-iterator property instead. - // Such inputs are accepted by the fallback and checked at runtime. - const enumerableInputs = { values: [1, 2], label: "inputs" }; - const enumerable = Iterator.zipKeyed(enumerableInputs).toArray(); + const a115 = { a: [1, 2], b: "inputs" }; + const a116 = Iterator.zipKeyed(a115).toArray(); - // The array's length and methods are not enumerable own properties. - const arrayInputs = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); + const a117 = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); - // The fallback must not claim that ignored properties exist on yielded objects. - const inheritedLabel: string = inherited[0].label; - ~~~~~~~~~~~~~~ + const a118: string = a108[0].b; + ~~~~ !!! error TS2322: Type 'unknown' is not assignable to type 'string'. - const nonEnumerableLabel: string = nonEnumerable[0].label; - ~~~~~~~~~~~~~~~~~~ + const a119: string = a113[0].b; + ~~~~ !!! error TS2322: Type 'unknown' is not assignable to type 'string'. - // Precise record inference still handles symbol keys and padding. - declare const ownKey: unique symbol; - const precise: { values: number; [ownKey]: string; }[] = Iterator.zipKeyed({ values: [1], [ownKey]: ["a"] }).toArray(); - const preciseLongest: { values: number | undefined; }[] = Iterator.zipKeyed({ values: [1] }, { mode: "longest" }).toArray(); - const precisePadded: { values: number; }[] = Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: 0 } }).toArray(); - const emptyOwnProperties: never[] = Iterator.zipKeyed({}).toArray(); + declare const a120: unique symbol; + const a121: { a: number; [a120]: string; }[] = Iterator.zipKeyed({ a: [1], [a120]: ["a"] }).toArray(); + const a122: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1] }, { mode: "longest" }).toArray(); + const a123: { a: number; }[] = Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray(); + + declare const a124: object; + const a125 = Iterator.zipKeyed(a124).toArray(); + const a126 = Iterator.zipKeyed(a124, { mode: "strict" }).toArray(); + const a127 = Iterator.zipKeyed(a124, { mode: "longest" }).toArray(); + const a128 = Iterator.zipKeyed(a124, { mode: "longest", padding: { a: 0 } }).toArray(); + const a129: unknown = a125[0].a; + const a130: unknown = a126[0].a; + const a131: unknown = a127[0].a; + const a132: unknown = a128[0].a; + const a133: never[] = a125; + ~~~~ +!!! error TS2322: Type 'Record[]' is not assignable to type 'never[]'. +!!! error TS2322: Type 'Record' is not assignable to type 'never'. + + declare const a134: {}; + const a135 = Iterator.zipKeyed(a134).toArray(); + const a136: unknown = a135[0].a; + const a137: never[] = a135; + ~~~~ +!!! error TS2322: Type 'Record[]' is not assignable to type 'never[]'. +!!! error TS2322: Type 'Record' is not assignable to type 'never'. Iterator.zipKeyed(0); ~ @@ -604,28 +618,28 @@ iteratorZip.ts(263,19): error TS2769: No overload matches this call. !!! error TS2769: The last overload gave the following error. !!! error TS2769: Argument of type 'null' is not assignable to parameter of type 'never'. !!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. - Iterator.zipKeyed(instance, { mode: "invalid" }); - ~~~~ + Iterator.zipKeyed(a107, { mode: "invalid" }); + ~~~~ !!! error TS2769: No overload matches this call. !!! error TS2769: The last overload gave the following error. !!! error TS2769: Type '"invalid"' is not assignable to type '"longest" | "shortest" | "strict" | undefined'. !!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. - Iterator.zipKeyed(instance, { mode: "shortest", padding: {} }); - ~~~~~~~ + Iterator.zipKeyed(a107, { mode: "shortest", padding: {} }); + ~~~~~~~ !!! error TS2769: No overload matches this call. !!! error TS2769: The last overload gave the following error. !!! error TS2769: Object literal may only specify known properties, and 'padding' does not exist in type 'IteratorZipShortestOptions'. !!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. - Iterator.zipKeyed(instance, { mode: "longest", padding: 0 }); - ~~~~~~~ + Iterator.zipKeyed(a107, { mode: "longest", padding: 0 }); + ~~~~~~~ !!! error TS2769: No overload matches this call. !!! error TS2769: The last overload gave the following error. !!! error TS2769: Type 'number' is not assignable to type 'object'. !!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. - Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: "invalid" } }); - ~~~~~~~~~~~~~~~ + Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: "invalid" } }); + ~~~~~~~~~~ !!! error TS2769: No overload matches this call. !!! error TS2769: The last overload gave the following error. -!!! error TS2769: Argument of type '{ values: number[]; }' is not assignable to parameter of type 'never'. +!!! error TS2769: Argument of type '{ a: number[]; }' is not assignable to parameter of type 'never'. !!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).js b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).js index 893920834439d..e625116d58970 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).js +++ b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).js @@ -1,66 +1,66 @@ //// [tests/cases/compiler/iteratorZip.ts] //// //// [iteratorZip.ts] -declare const key: unique symbol; +declare const a1: unique symbol; -const tuples: [number, string][] = Iterator.zip([ +const a2: [number, string][] = Iterator.zip([ [1, 2], new Set(["a", "b"]), ] as const).toArray(); -tuples[0][0] = 2; +a2[0][0] = 2; -const shortestTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray(); -const strictTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray(); -const longestTuplesWithPadding: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray(); -const longestTuplesWithoutPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray(); -const longestTuplesWithPartialPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray(); +const a3: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray(); +const a4: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray(); +const a5: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray(); +const a6: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray(); +const a7: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray(); -declare const maybeLongestOptions: { mode: "shortest"; } | { mode: "longest"; }; -const maybeLongestTuples: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray(); +declare const a8: { mode: "shortest"; } | { mode: "longest"; }; +const a9: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, a8).toArray(); -const empty: never[] = Iterator.zip([]).toArray(); -const emptyLongest: never[] = Iterator.zip([], { mode: "longest" }).toArray(); +const a10: never[] = Iterator.zip([]).toArray(); +const a11: never[] = Iterator.zip([], { mode: "longest" }).toArray(); -declare const iterables: Iterable>; -const arrays: number[][] = Iterator.zip(iterables).toArray(); -const longestArrays: (number | undefined)[][] = Iterator.zip(iterables, { mode: "longest" }).toArray(); -const maybeLongestArrays: (number | undefined)[][] = Iterator.zip(iterables, maybeLongestOptions).toArray(); +declare const a12: Iterable>; +const a13: number[][] = Iterator.zip(a12).toArray(); +const a14: (number | undefined)[][] = Iterator.zip(a12, { mode: "longest" }).toArray(); +const a15: (number | undefined)[][] = Iterator.zip(a12, a8).toArray(); -declare const iterableArray: Iterable[]; -const longestArrayWithPadding: (number | undefined)[][] = Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray(); +declare const a16: Iterable[]; +const a17: (number | undefined)[][] = Iterator.zip(a16, { mode: "longest", padding: [] }).toArray(); -const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ +const a18: { a: number; b: string; [a1]: boolean; }[] = Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), - [key]: [true, false], + [a1]: [true, false], } as const).toArray(); -objects[0].a = 2; +a18[0].a = 2; -const longestObjectsWithPadding: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +const a19: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" }, }).toArray(); -const longestObjectsWithoutPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +const a20: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", }).toArray(); -const longestObjectsWithPartialPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +const a21: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" }, }).toArray(); -const maybeLongestObjects: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray(); +const a22: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, a8).toArray(); -interface Inputs { +interface I1 { a: Iterable; b: Iterator; } -declare const inputs: Inputs; -const rows: { a: number; b: string; }[] = Iterator.zipKeyed(inputs).toArray(); +declare const a23: I1; +const a24: { a: number; b: string; }[] = Iterator.zipKeyed(a23).toArray(); Iterator.zip([[1]], { mode: "invalid" }); @@ -72,13 +72,11 @@ Iterator.zip(0); Iterator.zipKeyed({ a: 0 }); -const emptyKeyed: never[] = Iterator.zipKeyed({}).toArray(); -const emptyKeyedLongest: never[] = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); +const a25: Record[] = Iterator.zipKeyed({}).toArray(); +const a26: Record[] = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); -declare const unionInputs: { a: Iterable; } | { b: Iterator; }; -const unionRows: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(unionInputs).toArray(); - -// Inputs +declare const a27: { a: Iterable; } | { b: Iterator; }; +const a28: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(a27).toArray(); Iterator.zip("ab"); Iterator.zip(["ab"]); @@ -89,55 +87,55 @@ Iterator.zip([], { mode: "longest", padding: "ab" }); Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); -const a: [string][] = Iterator.zip([new String("ab")]).toArray(); -const b: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); -const c: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); +const a29: [string][] = Iterator.zip([new String("ab")]).toArray(); +const a30: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); +const a31: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); -const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); -const e: { a: number; }[] = d; -d[0].b; -const f: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); -const g: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); +const a32 = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); +const a33: { a: number; }[] = a32; +a32[0].b; +const a34: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); +const a35: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); -interface I { +interface I2 { readonly a: Iterable; readonly b?: Iterator; readonly c: Iterable | undefined; readonly d?: undefined; } -declare const h: I; -const i = Iterator.zipKeyed(h).toArray(); -const j: { a: number; b?: string; c?: boolean; }[] = i; -i[0].a = 2; -i[0].b = "a"; -i[0].c = true; -i[0].d; -const k: { a: number; c: boolean; }[] = i; -const l: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); - -declare const m: { a: Iterable; } | { b: Iterator; }; -const n: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(m).toArray(); -declare const o: { a: Iterable; } | { b: number; }; -Iterator.zipKeyed(o); -Iterator.zipKeyed(o, { mode: "longest" }); -Iterator.zipKeyed(o, { mode: "longest", padding: {} }); -declare const p: { a?: Iterable; } | { b: string; }; -Iterator.zipKeyed(p); -declare const q: { a: Iterable; } | { b: undefined; }; -const r: { a: number; }[] = Iterator.zipKeyed(q).toArray(); - -declare const s: unique symbol; -declare const t: { a: Iterable; [s]?: Iterable; }; -const u: { a: number; [s]?: string; }[] = Iterator.zipKeyed(t).toArray(); +declare const a36: I2; +const a37 = Iterator.zipKeyed(a36).toArray(); +const a38: { a: number; b?: string; c?: boolean; }[] = a37; +a37[0].a = 2; +a37[0].b = "a"; +a37[0].c = true; +a37[0].d; +const a39: { a: number; c: boolean; }[] = a37; +const a40: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(a36, { mode: "longest" }).toArray(); + +declare const a41: { a: Iterable; } | { b: Iterator; }; +const a42: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(a41).toArray(); +declare const a43: { a: Iterable; } | { b: number; }; +Iterator.zipKeyed(a43); +Iterator.zipKeyed(a43, { mode: "longest" }); +Iterator.zipKeyed(a43, { mode: "longest", padding: {} }); +declare const a44: { a?: Iterable; } | { b: string; }; +Iterator.zipKeyed(a44); +declare const a45: { a: Iterable; } | { b: undefined; }; +const a46: { a: number; }[] = Iterator.zipKeyed(a45).toArray(); + +declare const a47: unique symbol; +declare const a48: { a: Iterable; [a47]?: Iterable; }; +const a49: { a: number; [a47]?: string; }[] = Iterator.zipKeyed(a48).toArray(); Iterator.zipKeyed({ a: [1], b: null }); Iterator.zipKeyed({ a: [1], b: false }); Iterator.zip([undefined]); -declare const v: { a?: undefined; }; -const w: never[] = Iterator.zipKeyed(v).toArray(); -const x: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); -const y: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); +declare const a50: { a?: undefined; }; +const a51: never[] = Iterator.zipKeyed(a50).toArray(); +const a52: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); +const a53: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); function f1(a: Iterable) { const b: { a: T; }[] = Iterator.zipKeyed({ a }).toArray(); @@ -145,174 +143,179 @@ function f1(a: Iterable) { return { b, c }; } -// Padding - -const paddingA: [Iterable, ...Iterable[]] = [[1, 2], [3]]; -const paddingB = Iterator.zip(paddingA, { mode: "longest", padding: [0] }).toArray(); -const paddingC: (number | undefined)[][] = paddingB; -const paddingD: number[][] = paddingB; - -const paddingE: Record> = { a: [1], b: [2, 3] }; -const paddingF = Iterator.zipKeyed(paddingE, { mode: "longest", padding: {} }).toArray(); -const paddingG: Record[] = paddingF; -const paddingH: Record[] = paddingF; - -declare const paddingI: Record; -const paddingJ = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: paddingI }).toArray(); -const paddingK: { a: number | undefined; b: number | undefined; }[] = paddingJ; -const paddingL: { a: number; b: number; }[] = paddingJ; - -const paddingM = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); -const paddingN: [number, string][] = paddingM; -const paddingO = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); -const paddingP: { a: number; b: string; }[] = paddingO; - -const paddingQ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); -const paddingR: [number | undefined, string | undefined][] = paddingQ; -const paddingS: [number, string][] = paddingQ; -const paddingT = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); -const paddingU: { a: number | undefined; b: string | undefined; }[] = paddingT; -const paddingV: { a: number; b: string; }[] = paddingT; - -declare const paddingW: readonly [number, string]; -const paddingX: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingW }).toArray(); -declare const paddingY: [number, string?]; -const paddingZ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY }).toArray(); -const paddingA1: [number, string][] = paddingZ; - -declare const paddingB1: [Iterable] | [Iterable, Iterable]; -const paddingC1 = Iterator.zip(paddingB1, { mode: "longest", padding: [0] }).toArray(); -const paddingD1: number[][] = paddingC1; -declare const paddingE1: { a: Iterable; } | { b: Iterable; }; -const paddingF1 = Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: 0 } }).toArray(); -const paddingG1: ({ a: number; } | { b: string; })[] = paddingF1; - -declare const paddingH1: { a: number; } | { b: string; }; -const paddingI1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: paddingH1 }).toArray(); -const paddingJ1: { a: number; b: string; }[] = paddingI1; - -const paddingK1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); -const paddingL1: { a: number; b: number; }[] = paddingK1; - -declare const paddingM1: { [K in `a${string}`]: Iterable; }; -const paddingN1 = Iterator.zipKeyed(paddingM1, { mode: "longest", padding: {} }).toArray(); -const paddingO1: { [K in `a${string}`]: number; }[] = paddingN1; - -declare const paddingP1: unique symbol; -const paddingQ1: { [paddingP1]: number; }[] = Iterator.zipKeyed({ [paddingP1]: [1] }, { mode: "longest", padding: { [paddingP1]: 0 } }).toArray(); - -declare const paddingR1: Record & { a: number; }; -const paddingS1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: paddingR1 }).toArray(); -const paddingT1: { a: number; b: number | undefined; }[] = paddingS1; -const paddingU1: { a: number; b: number; }[] = paddingS1; - -declare const paddingV1: [number] | [number, string]; -const paddingW1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingV1 }).toArray(); -const paddingX1: [number, string | undefined][] = paddingW1; -const paddingY1: [number, string][] = paddingW1; - -const paddingZ1: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); -const paddingA2: { a: number | undefined; b: number; }[] = paddingK1; - -// Own properties - -class InputsWithPrototypeMembers { - values = [1, 2]; - - get label() { +const a54: [Iterable, ...Iterable[]] = [[1, 2], [3]]; +const a55 = Iterator.zip(a54, { mode: "longest", padding: [0] }).toArray(); +const a56: (number | undefined)[][] = a55; +const a57: number[][] = a55; + +const a58: Record> = { a: [1], b: [2, 3] }; +const a59 = Iterator.zipKeyed(a58, { mode: "longest", padding: {} }).toArray(); +const a60: Record[] = a59; +const a61: Record[] = a59; + +declare const a62: Record; +const a63 = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a62 }).toArray(); +const a64: { a: number | undefined; b: number | undefined; }[] = a63; +const a65: { a: number; b: number; }[] = a63; + +const a66 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); +const a67: [number, string][] = a66; +const a68 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); +const a69: { a: number; b: string; }[] = a68; + +const a70 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); +const a71: [number | undefined, string | undefined][] = a70; +const a72: [number, string][] = a70; +const a73 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); +const a74: { a: number | undefined; b: string | undefined; }[] = a73; +const a75: { a: number; b: string; }[] = a73; + +declare const a76: readonly [number, string]; +const a77: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a76 }).toArray(); +declare const a78: [number, string?]; +const a79 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a78 }).toArray(); +const a80: [number, string][] = a79; + +declare const a81: [Iterable] | [Iterable, Iterable]; +const a82 = Iterator.zip(a81, { mode: "longest", padding: [0] }).toArray(); +const a83: number[][] = a82; +declare const a84: { a: Iterable; } | { b: Iterable; }; +const a85 = Iterator.zipKeyed(a84, { mode: "longest", padding: { a: 0 } }).toArray(); +const a86: ({ a: number; } | { b: string; })[] = a85; + +declare const a87: { a: number; } | { b: string; }; +const a88 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: a87 }).toArray(); +const a89: { a: number; b: string; }[] = a88; + +const a90 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); +const a91: { a: number; b: number; }[] = a90; + +declare const a92: { [K in `a${string}`]: Iterable; }; +const a93 = Iterator.zipKeyed(a92, { mode: "longest", padding: {} }).toArray(); +const a94: { [K in `a${string}`]: number; }[] = a93; + +declare const a95: unique symbol; +const a96: { [a95]: number; }[] = Iterator.zipKeyed({ [a95]: [1] }, { mode: "longest", padding: { [a95]: 0 } }).toArray(); + +declare const a97: Record & { a: number; }; +const a98 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: a97 }).toArray(); +const a99: { a: number; b: number | undefined; }[] = a98; +const a100: { a: number; b: number; }[] = a98; + +declare const a101: [number] | [number, string]; +const a102 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a101 }).toArray(); +const a103: [number, string | undefined][] = a102; +const a104: [number, string][] = a102; + +const a105: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); +const a106: { a: number | undefined; b: number; }[] = a90; + +class C1 { + a = [1, 2]; + + get b() { return "inputs"; } - describe() { - return this.label; + f() { + return this.b; } } -const instance = new InputsWithPrototypeMembers(); -const inherited = Iterator.zipKeyed(instance).toArray(); -const inheritedStrict = Iterator.zipKeyed(instance, { mode: "strict" }).toArray(); -const inheritedLongest = Iterator.zipKeyed(instance, { mode: "longest" }).toArray(); -const inheritedPadded = Iterator.zipKeyed(instance, { mode: "longest", padding: { values: 0 } }).toArray(); - -const hiddenInputs = { values: [1, 2], label: "inputs" }; -Object.defineProperty(hiddenInputs, "label", { enumerable: false }); -const nonEnumerable = Iterator.zipKeyed(hiddenInputs).toArray(); -const nonEnumerablePadded = Iterator.zipKeyed(hiddenInputs, { mode: "longest", padding: { values: 0 } }).toArray(); - -// The same static shape can have an enumerable non-iterator property instead. -// Such inputs are accepted by the fallback and checked at runtime. -const enumerableInputs = { values: [1, 2], label: "inputs" }; -const enumerable = Iterator.zipKeyed(enumerableInputs).toArray(); - -// The array's length and methods are not enumerable own properties. -const arrayInputs = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); - -// The fallback must not claim that ignored properties exist on yielded objects. -const inheritedLabel: string = inherited[0].label; -const nonEnumerableLabel: string = nonEnumerable[0].label; - -// Precise record inference still handles symbol keys and padding. -declare const ownKey: unique symbol; -const precise: { values: number; [ownKey]: string; }[] = Iterator.zipKeyed({ values: [1], [ownKey]: ["a"] }).toArray(); -const preciseLongest: { values: number | undefined; }[] = Iterator.zipKeyed({ values: [1] }, { mode: "longest" }).toArray(); -const precisePadded: { values: number; }[] = Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: 0 } }).toArray(); -const emptyOwnProperties: never[] = Iterator.zipKeyed({}).toArray(); +const a107 = new C1(); +const a108 = Iterator.zipKeyed(a107).toArray(); +const a109 = Iterator.zipKeyed(a107, { mode: "strict" }).toArray(); +const a110 = Iterator.zipKeyed(a107, { mode: "longest" }).toArray(); +const a111 = Iterator.zipKeyed(a107, { mode: "longest", padding: { a: 0 } }).toArray(); + +const a112 = { a: [1, 2], b: "inputs" }; +Object.defineProperty(a112, "b", { enumerable: false }); +const a113 = Iterator.zipKeyed(a112).toArray(); +const a114 = Iterator.zipKeyed(a112, { mode: "longest", padding: { a: 0 } }).toArray(); + +const a115 = { a: [1, 2], b: "inputs" }; +const a116 = Iterator.zipKeyed(a115).toArray(); + +const a117 = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); + +const a118: string = a108[0].b; +const a119: string = a113[0].b; + +declare const a120: unique symbol; +const a121: { a: number; [a120]: string; }[] = Iterator.zipKeyed({ a: [1], [a120]: ["a"] }).toArray(); +const a122: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1] }, { mode: "longest" }).toArray(); +const a123: { a: number; }[] = Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray(); + +declare const a124: object; +const a125 = Iterator.zipKeyed(a124).toArray(); +const a126 = Iterator.zipKeyed(a124, { mode: "strict" }).toArray(); +const a127 = Iterator.zipKeyed(a124, { mode: "longest" }).toArray(); +const a128 = Iterator.zipKeyed(a124, { mode: "longest", padding: { a: 0 } }).toArray(); +const a129: unknown = a125[0].a; +const a130: unknown = a126[0].a; +const a131: unknown = a127[0].a; +const a132: unknown = a128[0].a; +const a133: never[] = a125; + +declare const a134: {}; +const a135 = Iterator.zipKeyed(a134).toArray(); +const a136: unknown = a135[0].a; +const a137: never[] = a135; Iterator.zipKeyed(0); Iterator.zipKeyed(null); -Iterator.zipKeyed(instance, { mode: "invalid" }); -Iterator.zipKeyed(instance, { mode: "shortest", padding: {} }); -Iterator.zipKeyed(instance, { mode: "longest", padding: 0 }); -Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: "invalid" } }); +Iterator.zipKeyed(a107, { mode: "invalid" }); +Iterator.zipKeyed(a107, { mode: "shortest", padding: {} }); +Iterator.zipKeyed(a107, { mode: "longest", padding: 0 }); +Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: "invalid" } }); //// [iteratorZip.js] "use strict"; -const tuples = Iterator.zip([ +const a2 = Iterator.zip([ [1, 2], new Set(["a", "b"]), ]).toArray(); -tuples[0][0] = 2; -const shortestTuples = Iterator.zip([[1], ["a"]], { mode: "shortest" }).toArray(); -const strictTuples = Iterator.zip([[1], ["a"]], { mode: "strict" }).toArray(); -const longestTuplesWithPadding = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [1, "a"] }).toArray(); -const longestTuplesWithoutPadding = Iterator.zip([[1], ["a"]], { mode: "longest" }).toArray(); -const longestTuplesWithPartialPadding = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [1] }).toArray(); -const maybeLongestTuples = Iterator.zip([[1], ["a"]], maybeLongestOptions).toArray(); -const empty = Iterator.zip([]).toArray(); -const emptyLongest = Iterator.zip([], { mode: "longest" }).toArray(); -const arrays = Iterator.zip(iterables).toArray(); -const longestArrays = Iterator.zip(iterables, { mode: "longest" }).toArray(); -const maybeLongestArrays = Iterator.zip(iterables, maybeLongestOptions).toArray(); -const longestArrayWithPadding = Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray(); -const objects = Iterator.zipKeyed({ +a2[0][0] = 2; +const a3 = Iterator.zip([[1], ["a"]], { mode: "shortest" }).toArray(); +const a4 = Iterator.zip([[1], ["a"]], { mode: "strict" }).toArray(); +const a5 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [1, "a"] }).toArray(); +const a6 = Iterator.zip([[1], ["a"]], { mode: "longest" }).toArray(); +const a7 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [1] }).toArray(); +const a9 = Iterator.zip([[1], ["a"]], a8).toArray(); +const a10 = Iterator.zip([]).toArray(); +const a11 = Iterator.zip([], { mode: "longest" }).toArray(); +const a13 = Iterator.zip(a12).toArray(); +const a14 = Iterator.zip(a12, { mode: "longest" }).toArray(); +const a15 = Iterator.zip(a12, a8).toArray(); +const a17 = Iterator.zip(a16, { mode: "longest", padding: [] }).toArray(); +const a18 = Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), - [key]: [true, false], + [a1]: [true, false], }).toArray(); -objects[0].a = 2; -const longestObjectsWithPadding = Iterator.zipKeyed({ a: [1], b: ["a"] }, { +a18[0].a = 2; +const a19 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 1, b: "a" }, }).toArray(); -const longestObjectsWithoutPadding = Iterator.zipKeyed({ a: [1], b: ["a"] }, { +const a20 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", }).toArray(); -const longestObjectsWithPartialPadding = Iterator.zipKeyed({ a: [1], b: ["a"] }, { +const a21 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { b: "a" }, }).toArray(); -const maybeLongestObjects = Iterator.zipKeyed({ a: [1], b: ["a"] }, maybeLongestOptions).toArray(); -const rows = Iterator.zipKeyed(inputs).toArray(); +const a22 = Iterator.zipKeyed({ a: [1], b: ["a"] }, a8).toArray(); +const a24 = Iterator.zipKeyed(a23).toArray(); Iterator.zip([[1]], { mode: "invalid" }); Iterator.zip([[1], ["a"]], { mode: "longest", padding: [true] }); Iterator.zip([[1]], { mode: "shortest", padding: [1] }); Iterator.zip(0); Iterator.zipKeyed({ a: 0 }); -const emptyKeyed = Iterator.zipKeyed({}).toArray(); -const emptyKeyedLongest = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); -const unionRows = Iterator.zipKeyed(unionInputs).toArray(); -// Inputs +const a25 = Iterator.zipKeyed({}).toArray(); +const a26 = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); +const a28 = Iterator.zipKeyed(a27).toArray(); Iterator.zip("ab"); Iterator.zip(["ab"]); Iterator.zip(new Set(["ab"])); @@ -321,272 +324,278 @@ Iterator.zipKeyed({ a: "ab" }); Iterator.zip([], { mode: "longest", padding: "ab" }); Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); -const a = Iterator.zip([new String("ab")]).toArray(); -const b = Iterator.zipKeyed({ a: new String("ab") }).toArray(); -const c = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); -const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); -const e = d; -d[0].b; -const f = Iterator.zipKeyed({ a: undefined }).toArray(); -const g = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); -const i = Iterator.zipKeyed(h).toArray(); -const j = i; -i[0].a = 2; -i[0].b = "a"; -i[0].c = true; -i[0].d; -const k = i; -const l = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); -const n = Iterator.zipKeyed(m).toArray(); -Iterator.zipKeyed(o); -Iterator.zipKeyed(o, { mode: "longest" }); -Iterator.zipKeyed(o, { mode: "longest", padding: {} }); -Iterator.zipKeyed(p); -const r = Iterator.zipKeyed(q).toArray(); -const u = Iterator.zipKeyed(t).toArray(); +const a29 = Iterator.zip([new String("ab")]).toArray(); +const a30 = Iterator.zipKeyed({ a: new String("ab") }).toArray(); +const a31 = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); +const a32 = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); +const a33 = a32; +a32[0].b; +const a34 = Iterator.zipKeyed({ a: undefined }).toArray(); +const a35 = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); +const a37 = Iterator.zipKeyed(a36).toArray(); +const a38 = a37; +a37[0].a = 2; +a37[0].b = "a"; +a37[0].c = true; +a37[0].d; +const a39 = a37; +const a40 = Iterator.zipKeyed(a36, { mode: "longest" }).toArray(); +const a42 = Iterator.zipKeyed(a41).toArray(); +Iterator.zipKeyed(a43); +Iterator.zipKeyed(a43, { mode: "longest" }); +Iterator.zipKeyed(a43, { mode: "longest", padding: {} }); +Iterator.zipKeyed(a44); +const a46 = Iterator.zipKeyed(a45).toArray(); +const a49 = Iterator.zipKeyed(a48).toArray(); Iterator.zipKeyed({ a: [1], b: null }); Iterator.zipKeyed({ a: [1], b: false }); Iterator.zip([undefined]); -const w = Iterator.zipKeyed(v).toArray(); -const x = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); -const y = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); +const a51 = Iterator.zipKeyed(a50).toArray(); +const a52 = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); +const a53 = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); function f1(a) { const b = Iterator.zipKeyed({ a }).toArray(); const c = Iterator.zip([a]).toArray(); return { b, c }; } -// Padding -const paddingA = [[1, 2], [3]]; -const paddingB = Iterator.zip(paddingA, { mode: "longest", padding: [0] }).toArray(); -const paddingC = paddingB; -const paddingD = paddingB; -const paddingE = { a: [1], b: [2, 3] }; -const paddingF = Iterator.zipKeyed(paddingE, { mode: "longest", padding: {} }).toArray(); -const paddingG = paddingF; -const paddingH = paddingF; -const paddingJ = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: paddingI }).toArray(); -const paddingK = paddingJ; -const paddingL = paddingJ; -const paddingM = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); -const paddingN = paddingM; -const paddingO = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); -const paddingP = paddingO; -const paddingQ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); -const paddingR = paddingQ; -const paddingS = paddingQ; -const paddingT = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); -const paddingU = paddingT; -const paddingV = paddingT; -const paddingX = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingW }).toArray(); -const paddingZ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY }).toArray(); -const paddingA1 = paddingZ; -const paddingC1 = Iterator.zip(paddingB1, { mode: "longest", padding: [0] }).toArray(); -const paddingD1 = paddingC1; -const paddingF1 = Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: 0 } }).toArray(); -const paddingG1 = paddingF1; -const paddingI1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: paddingH1 }).toArray(); -const paddingJ1 = paddingI1; -const paddingK1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); -const paddingL1 = paddingK1; -const paddingN1 = Iterator.zipKeyed(paddingM1, { mode: "longest", padding: {} }).toArray(); -const paddingO1 = paddingN1; -const paddingQ1 = Iterator.zipKeyed({ [paddingP1]: [1] }, { mode: "longest", padding: { [paddingP1]: 0 } }).toArray(); -const paddingS1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: paddingR1 }).toArray(); -const paddingT1 = paddingS1; -const paddingU1 = paddingS1; -const paddingW1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingV1 }).toArray(); -const paddingX1 = paddingW1; -const paddingY1 = paddingW1; -const paddingZ1 = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); -const paddingA2 = paddingK1; -// Own properties -class InputsWithPrototypeMembers { - values = [1, 2]; - get label() { +const a54 = [[1, 2], [3]]; +const a55 = Iterator.zip(a54, { mode: "longest", padding: [0] }).toArray(); +const a56 = a55; +const a57 = a55; +const a58 = { a: [1], b: [2, 3] }; +const a59 = Iterator.zipKeyed(a58, { mode: "longest", padding: {} }).toArray(); +const a60 = a59; +const a61 = a59; +const a63 = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a62 }).toArray(); +const a64 = a63; +const a65 = a63; +const a66 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); +const a67 = a66; +const a68 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); +const a69 = a68; +const a70 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); +const a71 = a70; +const a72 = a70; +const a73 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); +const a74 = a73; +const a75 = a73; +const a77 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a76 }).toArray(); +const a79 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a78 }).toArray(); +const a80 = a79; +const a82 = Iterator.zip(a81, { mode: "longest", padding: [0] }).toArray(); +const a83 = a82; +const a85 = Iterator.zipKeyed(a84, { mode: "longest", padding: { a: 0 } }).toArray(); +const a86 = a85; +const a88 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: a87 }).toArray(); +const a89 = a88; +const a90 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); +const a91 = a90; +const a93 = Iterator.zipKeyed(a92, { mode: "longest", padding: {} }).toArray(); +const a94 = a93; +const a96 = Iterator.zipKeyed({ [a95]: [1] }, { mode: "longest", padding: { [a95]: 0 } }).toArray(); +const a98 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: a97 }).toArray(); +const a99 = a98; +const a100 = a98; +const a102 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a101 }).toArray(); +const a103 = a102; +const a104 = a102; +const a105 = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); +const a106 = a90; +class C1 { + a = [1, 2]; + get b() { return "inputs"; } - describe() { - return this.label; + f() { + return this.b; } } -const instance = new InputsWithPrototypeMembers(); -const inherited = Iterator.zipKeyed(instance).toArray(); -const inheritedStrict = Iterator.zipKeyed(instance, { mode: "strict" }).toArray(); -const inheritedLongest = Iterator.zipKeyed(instance, { mode: "longest" }).toArray(); -const inheritedPadded = Iterator.zipKeyed(instance, { mode: "longest", padding: { values: 0 } }).toArray(); -const hiddenInputs = { values: [1, 2], label: "inputs" }; -Object.defineProperty(hiddenInputs, "label", { enumerable: false }); -const nonEnumerable = Iterator.zipKeyed(hiddenInputs).toArray(); -const nonEnumerablePadded = Iterator.zipKeyed(hiddenInputs, { mode: "longest", padding: { values: 0 } }).toArray(); -// The same static shape can have an enumerable non-iterator property instead. -// Such inputs are accepted by the fallback and checked at runtime. -const enumerableInputs = { values: [1, 2], label: "inputs" }; -const enumerable = Iterator.zipKeyed(enumerableInputs).toArray(); -// The array's length and methods are not enumerable own properties. -const arrayInputs = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); -// The fallback must not claim that ignored properties exist on yielded objects. -const inheritedLabel = inherited[0].label; -const nonEnumerableLabel = nonEnumerable[0].label; -const precise = Iterator.zipKeyed({ values: [1], [ownKey]: ["a"] }).toArray(); -const preciseLongest = Iterator.zipKeyed({ values: [1] }, { mode: "longest" }).toArray(); -const precisePadded = Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: 0 } }).toArray(); -const emptyOwnProperties = Iterator.zipKeyed({}).toArray(); +const a107 = new C1(); +const a108 = Iterator.zipKeyed(a107).toArray(); +const a109 = Iterator.zipKeyed(a107, { mode: "strict" }).toArray(); +const a110 = Iterator.zipKeyed(a107, { mode: "longest" }).toArray(); +const a111 = Iterator.zipKeyed(a107, { mode: "longest", padding: { a: 0 } }).toArray(); +const a112 = { a: [1, 2], b: "inputs" }; +Object.defineProperty(a112, "b", { enumerable: false }); +const a113 = Iterator.zipKeyed(a112).toArray(); +const a114 = Iterator.zipKeyed(a112, { mode: "longest", padding: { a: 0 } }).toArray(); +const a115 = { a: [1, 2], b: "inputs" }; +const a116 = Iterator.zipKeyed(a115).toArray(); +const a117 = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); +const a118 = a108[0].b; +const a119 = a113[0].b; +const a121 = Iterator.zipKeyed({ a: [1], [a120]: ["a"] }).toArray(); +const a122 = Iterator.zipKeyed({ a: [1] }, { mode: "longest" }).toArray(); +const a123 = Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray(); +const a125 = Iterator.zipKeyed(a124).toArray(); +const a126 = Iterator.zipKeyed(a124, { mode: "strict" }).toArray(); +const a127 = Iterator.zipKeyed(a124, { mode: "longest" }).toArray(); +const a128 = Iterator.zipKeyed(a124, { mode: "longest", padding: { a: 0 } }).toArray(); +const a129 = a125[0].a; +const a130 = a126[0].a; +const a131 = a127[0].a; +const a132 = a128[0].a; +const a133 = a125; +const a135 = Iterator.zipKeyed(a134).toArray(); +const a136 = a135[0].a; +const a137 = a135; Iterator.zipKeyed(0); Iterator.zipKeyed(null); -Iterator.zipKeyed(instance, { mode: "invalid" }); -Iterator.zipKeyed(instance, { mode: "shortest", padding: {} }); -Iterator.zipKeyed(instance, { mode: "longest", padding: 0 }); -Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: "invalid" } }); +Iterator.zipKeyed(a107, { mode: "invalid" }); +Iterator.zipKeyed(a107, { mode: "shortest", padding: {} }); +Iterator.zipKeyed(a107, { mode: "longest", padding: 0 }); +Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: "invalid" } }); //// [iteratorZip.d.ts] -declare const key: unique symbol; -declare const tuples: [number, string][]; -declare const shortestTuples: [number, string][]; -declare const strictTuples: [number, string][]; -declare const longestTuplesWithPadding: [number, string][]; -declare const longestTuplesWithoutPadding: [number | undefined, string | undefined][]; -declare const longestTuplesWithPartialPadding: [number | undefined, string | undefined][]; -declare const maybeLongestOptions: { +declare const a1: unique symbol; +declare const a2: [number, string][]; +declare const a3: [number, string][]; +declare const a4: [number, string][]; +declare const a5: [number, string][]; +declare const a6: [number | undefined, string | undefined][]; +declare const a7: [number | undefined, string | undefined][]; +declare const a8: { mode: "shortest"; } | { mode: "longest"; }; -declare const maybeLongestTuples: [number | undefined, string | undefined][]; -declare const empty: never[]; -declare const emptyLongest: never[]; -declare const iterables: Iterable>; -declare const arrays: number[][]; -declare const longestArrays: (number | undefined)[][]; -declare const maybeLongestArrays: (number | undefined)[][]; -declare const iterableArray: Iterable[]; -declare const longestArrayWithPadding: (number | undefined)[][]; -declare const objects: { +declare const a9: [number | undefined, string | undefined][]; +declare const a10: never[]; +declare const a11: never[]; +declare const a12: Iterable>; +declare const a13: number[][]; +declare const a14: (number | undefined)[][]; +declare const a15: (number | undefined)[][]; +declare const a16: Iterable[]; +declare const a17: (number | undefined)[][]; +declare const a18: { a: number; b: string; - [key]: boolean; + [a1]: boolean; }[]; -declare const longestObjectsWithPadding: { +declare const a19: { a: number; b: string; }[]; -declare const longestObjectsWithoutPadding: { +declare const a20: { a: number | undefined; b: string | undefined; }[]; -declare const longestObjectsWithPartialPadding: { +declare const a21: { a: number | undefined; b: string | undefined; }[]; -declare const maybeLongestObjects: { +declare const a22: { a: number | undefined; b: string | undefined; }[]; -interface Inputs { +interface I1 { a: Iterable; b: Iterator; } -declare const inputs: Inputs; -declare const rows: { +declare const a23: I1; +declare const a24: { a: number; b: string; }[]; -declare const emptyKeyed: never[]; -declare const emptyKeyedLongest: never[]; -declare const unionInputs: { +declare const a25: Record[]; +declare const a26: Record[]; +declare const a27: { a: Iterable; } | { b: Iterator; }; -declare const unionRows: ({ +declare const a28: ({ a: number; } | { b: string; })[]; -declare const a: [string][]; -declare const b: { +declare const a29: [string][]; +declare const a30: { a: string; }[]; -declare const c: (string | undefined)[][]; -declare const d: { +declare const a31: (string | undefined)[][]; +declare const a32: ({ a: number; -}[]; -declare const e: { +} & {})[]; +declare const a33: { a: number; }[]; -declare const f: never[]; -declare const g: never[]; -interface I { +declare const a34: never[]; +declare const a35: never[]; +interface I2 { readonly a: Iterable; readonly b?: Iterator; readonly c: Iterable | undefined; readonly d?: undefined; } -declare const h: I; -declare const i: { +declare const a36: I2; +declare const a37: ({ a: number; +} & { b?: string; c?: boolean; -}[]; -declare const j: { +})[]; +declare const a38: { a: number; b?: string; c?: boolean; }[]; -declare const k: { +declare const a39: { a: number; c: boolean; }[]; -declare const l: { +declare const a40: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[]; -declare const m: { +declare const a41: { a: Iterable; } | { b: Iterator; }; -declare const n: ({ +declare const a42: ({ a: number; } | { b: string; })[]; -declare const o: { +declare const a43: { a: Iterable; } | { b: number; }; -declare const p: { +declare const a44: { a?: Iterable; } | { b: string; }; -declare const q: { +declare const a45: { a: Iterable; } | { b: undefined; }; -declare const r: { +declare const a46: { a: number; }[]; -declare const s: unique symbol; -declare const t: { +declare const a47: unique symbol; +declare const a48: { a: Iterable; - [s]?: Iterable; + [a47]?: Iterable; }; -declare const u: { +declare const a49: { a: number; - [s]?: string; + [a47]?: string; }[]; -declare const v: { +declare const a50: { a?: undefined; }; -declare const w: never[]; -declare const x: { +declare const a51: never[]; +declare const a52: { a: number; }[]; -declare const y: { +declare const a53: { a: number | undefined; }[]; declare function f1(a: Iterable): { @@ -595,168 +604,181 @@ declare function f1(a: Iterable): { }[]; c: [T][]; }; -declare const paddingA: [Iterable, ...Iterable[]]; -declare const paddingB: [number, ...(number | undefined)[]][]; -declare const paddingC: (number | undefined)[][]; -declare const paddingD: number[][]; -declare const paddingE: Record>; -declare const paddingF: { +declare const a54: [Iterable, ...Iterable[]]; +declare const a55: [number, ...(number | undefined)[]][]; +declare const a56: (number | undefined)[][]; +declare const a57: number[][]; +declare const a58: Record>; +declare const a59: ({ [x: string]: number | undefined; -}[]; -declare const paddingG: Record[]; -declare const paddingH: Record[]; -declare const paddingI: Record; -declare const paddingJ: { +} & {})[]; +declare const a60: Record[]; +declare const a61: Record[]; +declare const a62: Record; +declare const a63: ({ a: number | undefined; b: number | undefined; -}[]; -declare const paddingK: { +} & {})[]; +declare const a64: { a: number | undefined; b: number | undefined; }[]; -declare const paddingL: { +declare const a65: { a: number; b: number; }[]; -declare const paddingM: [number, string][]; -declare const paddingN: [number, string][]; -declare const paddingO: { +declare const a66: [number, string][]; +declare const a67: [number, string][]; +declare const a68: ({ a: number; b: string; -}[]; -declare const paddingP: { +} & {})[]; +declare const a69: { a: number; b: string; }[]; -declare const paddingQ: [number, string | undefined][]; -declare const paddingR: [number | undefined, string | undefined][]; -declare const paddingS: [number, string][]; -declare const paddingT: { +declare const a70: [number, string | undefined][]; +declare const a71: [number | undefined, string | undefined][]; +declare const a72: [number, string][]; +declare const a73: ({ a: number; b: string | undefined; -}[]; -declare const paddingU: { +} & {})[]; +declare const a74: { a: number | undefined; b: string | undefined; }[]; -declare const paddingV: { +declare const a75: { a: number; b: string; }[]; -declare const paddingW: readonly [number, string]; -declare const paddingX: [number, string][]; -declare const paddingY: [number, string?]; -declare const paddingZ: [number, string | undefined][]; -declare const paddingA1: [number, string][]; -declare const paddingB1: [Iterable] | [Iterable, Iterable]; -declare const paddingC1: ([number] | [number, number | undefined])[]; -declare const paddingD1: number[][]; -declare const paddingE1: { +declare const a76: readonly [number, string]; +declare const a77: [number, string][]; +declare const a78: [number, string?]; +declare const a79: [number, string | undefined][]; +declare const a80: [number, string][]; +declare const a81: [Iterable] | [Iterable, Iterable]; +declare const a82: ([number] | [number, number | undefined])[]; +declare const a83: number[][]; +declare const a84: { a: Iterable; } | { b: Iterable; }; -declare const paddingF1: ({ +declare const a85: (({ a: number; -} | { +} & {}) | ({ b: string | undefined; -})[]; -declare const paddingG1: ({ +} & {}))[]; +declare const a86: ({ a: number; } | { b: string; })[]; -declare const paddingH1: { +declare const a87: { a: number; } | { b: string; }; -declare const paddingI1: { +declare const a88: ({ a: number | undefined; b: string | undefined; -}[]; -declare const paddingJ1: { +} & {})[]; +declare const a89: { a: number; b: string; }[]; -declare const paddingK1: { +declare const a90: ({ a: number | undefined; b: number; -}[]; -declare const paddingL1: { +} & {})[]; +declare const a91: { a: number; b: number; }[]; -declare const paddingM1: { +declare const a92: { [K in `a${string}`]: Iterable; }; -declare const paddingN1: { +declare const a93: ({ [x: `a${string}`]: number | undefined; -}[]; -declare const paddingO1: { +} & {})[]; +declare const a94: { [K in `a${string}`]: number; }[]; -declare const paddingP1: unique symbol; -declare const paddingQ1: { - [paddingP1]: number; +declare const a95: unique symbol; +declare const a96: { + [a95]: number; }[]; -declare const paddingR1: Record & { +declare const a97: Record & { a: number; }; -declare const paddingS1: { +declare const a98: ({ a: number; b: number | undefined; -}[]; -declare const paddingT1: { +} & {})[]; +declare const a99: { a: number; b: number | undefined; }[]; -declare const paddingU1: { +declare const a100: { a: number; b: number; }[]; -declare const paddingV1: [number] | [number, string]; -declare const paddingW1: [number, string | undefined][]; -declare const paddingX1: [number, string | undefined][]; -declare const paddingY1: [number, string][]; -declare const paddingZ1: [number | undefined, number][]; -declare const paddingA2: { +declare const a101: [number] | [number, string]; +declare const a102: [number, string | undefined][]; +declare const a103: [number, string | undefined][]; +declare const a104: [number, string][]; +declare const a105: [number | undefined, number][]; +declare const a106: { a: number | undefined; b: number; }[]; -declare class InputsWithPrototypeMembers { - values: number[]; - get label(): string; - describe(): string; +declare class C1 { + a: number[]; + get b(): string; + f(): string; } -declare const instance: InputsWithPrototypeMembers; -declare const inherited: Record[]; -declare const inheritedStrict: Record[]; -declare const inheritedLongest: Record[]; -declare const inheritedPadded: Record[]; -declare const hiddenInputs: { - values: number[]; - label: string; +declare const a107: C1; +declare const a108: Record[]; +declare const a109: Record[]; +declare const a110: Record[]; +declare const a111: Record[]; +declare const a112: { + a: number[]; + b: string; }; -declare const nonEnumerable: Record[]; -declare const nonEnumerablePadded: Record[]; -declare const enumerableInputs: { - values: number[]; - label: string; +declare const a113: Record[]; +declare const a114: Record[]; +declare const a115: { + a: number[]; + b: string; }; -declare const enumerable: Record[]; -declare const arrayInputs: Record[]; -declare const inheritedLabel: string; -declare const nonEnumerableLabel: string; -declare const ownKey: unique symbol; -declare const precise: { - values: number; - [ownKey]: string; +declare const a116: Record[]; +declare const a117: Record[]; +declare const a118: string; +declare const a119: string; +declare const a120: unique symbol; +declare const a121: { + a: number; + [a120]: string; }[]; -declare const preciseLongest: { - values: number | undefined; +declare const a122: { + a: number | undefined; }[]; -declare const precisePadded: { - values: number; +declare const a123: { + a: number; }[]; -declare const emptyOwnProperties: never[]; +declare const a124: object; +declare const a125: Record[]; +declare const a126: Record[]; +declare const a127: Record[]; +declare const a128: Record[]; +declare const a129: unknown; +declare const a130: unknown; +declare const a131: unknown; +declare const a132: unknown; +declare const a133: never[]; +declare const a134: {}; +declare const a135: Record[]; +declare const a136: unknown; +declare const a137: never[]; diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).symbols b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).symbols index 3314b80fc616e..14821dd34b801 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).symbols +++ b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).symbols @@ -1,11 +1,11 @@ //// [tests/cases/compiler/iteratorZip.ts] //// === iteratorZip.ts === -declare const key: unique symbol; ->key : Symbol(key, Decl(iteratorZip.ts, 0, 13)) +declare const a1: unique symbol; +>a1 : Symbol(a1, Decl(iteratorZip.ts, 0, 13)) -const tuples: [number, string][] = Iterator.zip([ ->tuples : Symbol(tuples, Decl(iteratorZip.ts, 2, 5)) +const a2: [number, string][] = Iterator.zip([ +>a2 : Symbol(a2, Decl(iteratorZip.ts, 2, 5)) >Iterator.zip([ [1, 2], new Set(["a", "b"]),] as const).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) @@ -19,188 +19,188 @@ const tuples: [number, string][] = Iterator.zip([ >const : Symbol(const) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -tuples[0][0] = 2; ->tuples : Symbol(tuples, Decl(iteratorZip.ts, 2, 5)) +a2[0][0] = 2; +>a2 : Symbol(a2, Decl(iteratorZip.ts, 2, 5)) >0 : Symbol(0) -const shortestTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray(); ->shortestTuples : Symbol(shortestTuples, Decl(iteratorZip.ts, 9, 5)) +const a3: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray(); +>a3 : Symbol(a3, Decl(iteratorZip.ts, 9, 5)) >Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >const : Symbol(const) ->mode : Symbol(mode, Decl(iteratorZip.ts, 9, 80)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 9, 68)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const strictTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray(); ->strictTuples : Symbol(strictTuples, Decl(iteratorZip.ts, 10, 5)) +const a4: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray(); +>a4 : Symbol(a4, Decl(iteratorZip.ts, 10, 5)) >Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >const : Symbol(const) ->mode : Symbol(mode, Decl(iteratorZip.ts, 10, 78)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 10, 68)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const longestTuplesWithPadding: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray(); ->longestTuplesWithPadding : Symbol(longestTuplesWithPadding, Decl(iteratorZip.ts, 11, 5)) +const a5: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray(); +>a5 : Symbol(a5, Decl(iteratorZip.ts, 11, 5)) >Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >const : Symbol(const) ->mode : Symbol(mode, Decl(iteratorZip.ts, 11, 90)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 11, 107)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 11, 68)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 11, 85)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const longestTuplesWithoutPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray(); ->longestTuplesWithoutPadding : Symbol(longestTuplesWithoutPadding, Decl(iteratorZip.ts, 12, 5)) +const a6: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray(); +>a6 : Symbol(a6, Decl(iteratorZip.ts, 12, 5)) >Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >const : Symbol(const) ->mode : Symbol(mode, Decl(iteratorZip.ts, 12, 117)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 12, 92)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const longestTuplesWithPartialPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray(); ->longestTuplesWithPartialPadding : Symbol(longestTuplesWithPartialPadding, Decl(iteratorZip.ts, 13, 5)) +const a7: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray(); +>a7 : Symbol(a7, Decl(iteratorZip.ts, 13, 5)) >Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >const : Symbol(const) ->mode : Symbol(mode, Decl(iteratorZip.ts, 13, 121)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 13, 138)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 13, 92)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 13, 109)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -declare const maybeLongestOptions: { mode: "shortest"; } | { mode: "longest"; }; ->maybeLongestOptions : Symbol(maybeLongestOptions, Decl(iteratorZip.ts, 15, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 15, 36)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 15, 60)) +declare const a8: { mode: "shortest"; } | { mode: "longest"; }; +>a8 : Symbol(a8, Decl(iteratorZip.ts, 15, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 15, 19)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 15, 43)) -const maybeLongestTuples: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray(); ->maybeLongestTuples : Symbol(maybeLongestTuples, Decl(iteratorZip.ts, 16, 5)) ->Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a9: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, a8).toArray(); +>a9 : Symbol(a9, Decl(iteratorZip.ts, 16, 5)) +>Iterator.zip([[1], ["a"]] as const, a8).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >const : Symbol(const) ->maybeLongestOptions : Symbol(maybeLongestOptions, Decl(iteratorZip.ts, 15, 13)) +>a8 : Symbol(a8, Decl(iteratorZip.ts, 15, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const empty: never[] = Iterator.zip([]).toArray(); ->empty : Symbol(empty, Decl(iteratorZip.ts, 18, 5)) +const a10: never[] = Iterator.zip([]).toArray(); +>a10 : Symbol(a10, Decl(iteratorZip.ts, 18, 5)) >Iterator.zip([]).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const emptyLongest: never[] = Iterator.zip([], { mode: "longest" }).toArray(); ->emptyLongest : Symbol(emptyLongest, Decl(iteratorZip.ts, 19, 5)) +const a11: never[] = Iterator.zip([], { mode: "longest" }).toArray(); +>a11 : Symbol(a11, Decl(iteratorZip.ts, 19, 5)) >Iterator.zip([], { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 19, 48)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 19, 39)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -declare const iterables: Iterable>; ->iterables : Symbol(iterables, Decl(iteratorZip.ts, 21, 13)) +declare const a12: Iterable>; +>a12 : Symbol(a12, Decl(iteratorZip.ts, 21, 13)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) -const arrays: number[][] = Iterator.zip(iterables).toArray(); ->arrays : Symbol(arrays, Decl(iteratorZip.ts, 22, 5)) ->Iterator.zip(iterables).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a13: number[][] = Iterator.zip(a12).toArray(); +>a13 : Symbol(a13, Decl(iteratorZip.ts, 22, 5)) +>Iterator.zip(a12).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->iterables : Symbol(iterables, Decl(iteratorZip.ts, 21, 13)) +>a12 : Symbol(a12, Decl(iteratorZip.ts, 21, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const longestArrays: (number | undefined)[][] = Iterator.zip(iterables, { mode: "longest" }).toArray(); ->longestArrays : Symbol(longestArrays, Decl(iteratorZip.ts, 23, 5)) ->Iterator.zip(iterables, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a14: (number | undefined)[][] = Iterator.zip(a12, { mode: "longest" }).toArray(); +>a14 : Symbol(a14, Decl(iteratorZip.ts, 23, 5)) +>Iterator.zip(a12, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->iterables : Symbol(iterables, Decl(iteratorZip.ts, 21, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 23, 73)) +>a12 : Symbol(a12, Decl(iteratorZip.ts, 21, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 23, 57)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const maybeLongestArrays: (number | undefined)[][] = Iterator.zip(iterables, maybeLongestOptions).toArray(); ->maybeLongestArrays : Symbol(maybeLongestArrays, Decl(iteratorZip.ts, 24, 5)) ->Iterator.zip(iterables, maybeLongestOptions).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a15: (number | undefined)[][] = Iterator.zip(a12, a8).toArray(); +>a15 : Symbol(a15, Decl(iteratorZip.ts, 24, 5)) +>Iterator.zip(a12, a8).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->iterables : Symbol(iterables, Decl(iteratorZip.ts, 21, 13)) ->maybeLongestOptions : Symbol(maybeLongestOptions, Decl(iteratorZip.ts, 15, 13)) +>a12 : Symbol(a12, Decl(iteratorZip.ts, 21, 13)) +>a8 : Symbol(a8, Decl(iteratorZip.ts, 15, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -declare const iterableArray: Iterable[]; ->iterableArray : Symbol(iterableArray, Decl(iteratorZip.ts, 26, 13)) +declare const a16: Iterable[]; +>a16 : Symbol(a16, Decl(iteratorZip.ts, 26, 13)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) -const longestArrayWithPadding: (number | undefined)[][] = Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray(); ->longestArrayWithPadding : Symbol(longestArrayWithPadding, Decl(iteratorZip.ts, 27, 5)) ->Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a17: (number | undefined)[][] = Iterator.zip(a16, { mode: "longest", padding: [] }).toArray(); +>a17 : Symbol(a17, Decl(iteratorZip.ts, 27, 5)) +>Iterator.zip(a16, { mode: "longest", padding: [] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->iterableArray : Symbol(iterableArray, Decl(iteratorZip.ts, 26, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 27, 87)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 27, 104)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ ->objects : Symbol(objects, Decl(iteratorZip.ts, 29, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 29, 16)) ->b : Symbol(b, Decl(iteratorZip.ts, 29, 27)) ->[key] : Symbol([key], Decl(iteratorZip.ts, 29, 38)) ->key : Symbol(key, Decl(iteratorZip.ts, 0, 13)) ->Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>a16 : Symbol(a16, Decl(iteratorZip.ts, 26, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 27, 57)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 27, 74)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a18: { a: number; b: string; [a1]: boolean; }[] = Iterator.zipKeyed({ +>a18 : Symbol(a18, Decl(iteratorZip.ts, 29, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 29, 12)) +>b : Symbol(b, Decl(iteratorZip.ts, 29, 23)) +>[a1] : Symbol([a1], Decl(iteratorZip.ts, 29, 34)) +>a1 : Symbol(a1, Decl(iteratorZip.ts, 0, 13)) +>Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [a1]: [true, false],} as const).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) a: [1, 2], ->a : Symbol(a, Decl(iteratorZip.ts, 29, 80)) +>a : Symbol(a, Decl(iteratorZip.ts, 29, 75)) b: new Set(["a", "b"]), >b : Symbol(b, Decl(iteratorZip.ts, 30, 14)) >Set : Symbol(Set, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) - [key]: [true, false], ->[key] : Symbol([key], Decl(iteratorZip.ts, 31, 27)) ->key : Symbol(key, Decl(iteratorZip.ts, 0, 13)) + [a1]: [true, false], +>[a1] : Symbol([a1], Decl(iteratorZip.ts, 31, 27)) +>a1 : Symbol(a1, Decl(iteratorZip.ts, 0, 13)) } as const).toArray(); >const : Symbol(const) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -objects[0].a = 2; ->objects[0].a : Symbol(a, Decl(iteratorZip.ts, 29, 16)) ->objects : Symbol(objects, Decl(iteratorZip.ts, 29, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 29, 16)) +a18[0].a = 2; +>a18[0].a : Symbol(a, Decl(iteratorZip.ts, 29, 12)) +>a18 : Symbol(a18, Decl(iteratorZip.ts, 29, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 29, 12)) -const longestObjectsWithPadding: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { ->longestObjectsWithPadding : Symbol(longestObjectsWithPadding, Decl(iteratorZip.ts, 37, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 37, 34)) ->b : Symbol(b, Decl(iteratorZip.ts, 37, 45)) +const a19: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +>a19 : Symbol(a19, Decl(iteratorZip.ts, 37, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 37, 12)) +>b : Symbol(b, Decl(iteratorZip.ts, 37, 23)) >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 37, 82)) ->b : Symbol(b, Decl(iteratorZip.ts, 37, 90)) +>a : Symbol(a, Decl(iteratorZip.ts, 37, 60)) +>b : Symbol(b, Decl(iteratorZip.ts, 37, 68)) >const : Symbol(const) mode: "longest", ->mode : Symbol(mode, Decl(iteratorZip.ts, 37, 113)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 37, 91)) padding: { a: 1, b: "a" }, >padding : Symbol(padding, Decl(iteratorZip.ts, 38, 20)) @@ -210,38 +210,38 @@ const longestObjectsWithPadding: { a: number; b: string; }[] = Iterator.zipKeyed }).toArray(); >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const longestObjectsWithoutPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { ->longestObjectsWithoutPadding : Symbol(longestObjectsWithoutPadding, Decl(iteratorZip.ts, 42, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 42, 37)) ->b : Symbol(b, Decl(iteratorZip.ts, 42, 60)) +const a20: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +>a20 : Symbol(a20, Decl(iteratorZip.ts, 42, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 42, 12)) +>b : Symbol(b, Decl(iteratorZip.ts, 42, 35)) >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 42, 109)) ->b : Symbol(b, Decl(iteratorZip.ts, 42, 117)) +>a : Symbol(a, Decl(iteratorZip.ts, 42, 84)) +>b : Symbol(b, Decl(iteratorZip.ts, 42, 92)) >const : Symbol(const) mode: "longest", ->mode : Symbol(mode, Decl(iteratorZip.ts, 42, 140)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 42, 115)) }).toArray(); >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const longestObjectsWithPartialPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { ->longestObjectsWithPartialPadding : Symbol(longestObjectsWithPartialPadding, Decl(iteratorZip.ts, 46, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 46, 41)) ->b : Symbol(b, Decl(iteratorZip.ts, 46, 64)) +const a21: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +>a21 : Symbol(a21, Decl(iteratorZip.ts, 46, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 46, 12)) +>b : Symbol(b, Decl(iteratorZip.ts, 46, 35)) >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 46, 113)) ->b : Symbol(b, Decl(iteratorZip.ts, 46, 121)) +>a : Symbol(a, Decl(iteratorZip.ts, 46, 84)) +>b : Symbol(b, Decl(iteratorZip.ts, 46, 92)) >const : Symbol(const) mode: "longest", ->mode : Symbol(mode, Decl(iteratorZip.ts, 46, 144)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 46, 115)) padding: { b: "a" }, >padding : Symbol(padding, Decl(iteratorZip.ts, 47, 20)) @@ -250,45 +250,45 @@ const longestObjectsWithPartialPadding: { a: number | undefined; b: string | und }).toArray(); >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const maybeLongestObjects: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray(); ->maybeLongestObjects : Symbol(maybeLongestObjects, Decl(iteratorZip.ts, 51, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 51, 28)) ->b : Symbol(b, Decl(iteratorZip.ts, 51, 51)) ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a22: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, a8).toArray(); +>a22 : Symbol(a22, Decl(iteratorZip.ts, 51, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 51, 12)) +>b : Symbol(b, Decl(iteratorZip.ts, 51, 35)) +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, a8).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 51, 100)) ->b : Symbol(b, Decl(iteratorZip.ts, 51, 108)) +>a : Symbol(a, Decl(iteratorZip.ts, 51, 84)) +>b : Symbol(b, Decl(iteratorZip.ts, 51, 92)) >const : Symbol(const) ->maybeLongestOptions : Symbol(maybeLongestOptions, Decl(iteratorZip.ts, 15, 13)) +>a8 : Symbol(a8, Decl(iteratorZip.ts, 15, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -interface Inputs { ->Inputs : Symbol(Inputs, Decl(iteratorZip.ts, 51, 161)) +interface I1 { +>I1 : Symbol(I1, Decl(iteratorZip.ts, 51, 128)) a: Iterable; ->a : Symbol(Inputs.a, Decl(iteratorZip.ts, 53, 18)) +>a : Symbol(I1.a, Decl(iteratorZip.ts, 53, 14)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) b: Iterator; ->b : Symbol(Inputs.b, Decl(iteratorZip.ts, 54, 24)) +>b : Symbol(I1.b, Decl(iteratorZip.ts, 54, 24)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) } -declare const inputs: Inputs; ->inputs : Symbol(inputs, Decl(iteratorZip.ts, 58, 13)) ->Inputs : Symbol(Inputs, Decl(iteratorZip.ts, 51, 161)) +declare const a23: I1; +>a23 : Symbol(a23, Decl(iteratorZip.ts, 58, 13)) +>I1 : Symbol(I1, Decl(iteratorZip.ts, 51, 128)) -const rows: { a: number; b: string; }[] = Iterator.zipKeyed(inputs).toArray(); ->rows : Symbol(rows, Decl(iteratorZip.ts, 59, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 59, 13)) ->b : Symbol(b, Decl(iteratorZip.ts, 59, 24)) ->Iterator.zipKeyed(inputs).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a24: { a: number; b: string; }[] = Iterator.zipKeyed(a23).toArray(); +>a24 : Symbol(a24, Decl(iteratorZip.ts, 59, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 59, 12)) +>b : Symbol(b, Decl(iteratorZip.ts, 59, 23)) +>Iterator.zipKeyed(a23).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->inputs : Symbol(inputs, Decl(iteratorZip.ts, 58, 13)) +>a23 : Symbol(a23, Decl(iteratorZip.ts, 58, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) Iterator.zip([[1]], { mode: "invalid" }); @@ -323,44 +323,46 @@ Iterator.zipKeyed({ a: 0 }); >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >a : Symbol(a, Decl(iteratorZip.ts, 69, 19)) -const emptyKeyed: never[] = Iterator.zipKeyed({}).toArray(); ->emptyKeyed : Symbol(emptyKeyed, Decl(iteratorZip.ts, 71, 5)) +const a25: Record[] = Iterator.zipKeyed({}).toArray(); +>a25 : Symbol(a25, Decl(iteratorZip.ts, 71, 5)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>PropertyKey : Symbol(PropertyKey, Decl(lib.es5.d.ts, --, --)) >Iterator.zipKeyed({}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const emptyKeyedLongest: never[] = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); ->emptyKeyedLongest : Symbol(emptyKeyedLongest, Decl(iteratorZip.ts, 72, 5)) +const a26: Record[] = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); +>a26 : Symbol(a26, Decl(iteratorZip.ts, 72, 5)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>PropertyKey : Symbol(PropertyKey, Decl(lib.es5.d.ts, --, --)) >Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 72, 58)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 72, 75)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 72, 67)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 72, 84)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -declare const unionInputs: { a: Iterable; } | { b: Iterator; }; ->unionInputs : Symbol(unionInputs, Decl(iteratorZip.ts, 74, 13)) ->a : Symbol(a, Decl(iteratorZip.ts, 74, 28)) +declare const a27: { a: Iterable; } | { b: Iterator; }; +>a27 : Symbol(a27, Decl(iteratorZip.ts, 74, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 74, 20)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->b : Symbol(b, Decl(iteratorZip.ts, 74, 55)) +>b : Symbol(b, Decl(iteratorZip.ts, 74, 47)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) -const unionRows: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(unionInputs).toArray(); ->unionRows : Symbol(unionRows, Decl(iteratorZip.ts, 75, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 75, 19)) ->b : Symbol(b, Decl(iteratorZip.ts, 75, 36)) ->Iterator.zipKeyed(unionInputs).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a28: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(a27).toArray(); +>a28 : Symbol(a28, Decl(iteratorZip.ts, 75, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 75, 13)) +>b : Symbol(b, Decl(iteratorZip.ts, 75, 30)) +>Iterator.zipKeyed(a27).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->unionInputs : Symbol(unionInputs, Decl(iteratorZip.ts, 74, 13)) +>a27 : Symbol(a27, Decl(iteratorZip.ts, 74, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -// Inputs - Iterator.zip("ab"); >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) @@ -386,31 +388,31 @@ Iterator.zipKeyed({ a: "ab" }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 83, 19)) +>a : Symbol(a, Decl(iteratorZip.ts, 81, 19)) Iterator.zip([], { mode: "longest", padding: "ab" }); >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 84, 18)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 84, 35)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 82, 18)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 82, 35)) Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 85, 23)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 85, 40)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 83, 23)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 83, 40)) Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 86, 23)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 86, 40)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 84, 23)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 84, 40)) -const a: [string][] = Iterator.zip([new String("ab")]).toArray(); ->a : Symbol(a, Decl(iteratorZip.ts, 88, 5)) +const a29: [string][] = Iterator.zip([new String("ab")]).toArray(); +>a29 : Symbol(a29, Decl(iteratorZip.ts, 86, 5)) >Iterator.zip([new String("ab")]).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) @@ -418,253 +420,253 @@ const a: [string][] = Iterator.zip([new String("ab")]).toArray(); >String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const b: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); ->b : Symbol(b, Decl(iteratorZip.ts, 89, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 89, 10)) +const a30: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); +>a30 : Symbol(a30, Decl(iteratorZip.ts, 87, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 87, 12)) >Iterator.zipKeyed({ a: new String("ab") }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 89, 47)) +>a : Symbol(a, Decl(iteratorZip.ts, 87, 49)) >String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const c: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); ->c : Symbol(c, Decl(iteratorZip.ts, 90, 5)) +const a31: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); +>a31 : Symbol(a31, Decl(iteratorZip.ts, 88, 5)) >Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 90, 59)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 90, 76)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 88, 61)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 88, 78)) >String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); ->d : Symbol(d, Decl(iteratorZip.ts, 92, 5)) +const a32 = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); +>a32 : Symbol(a32, Decl(iteratorZip.ts, 90, 5)) >Iterator.zipKeyed({ a: [1], b: undefined }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 92, 29)) ->b : Symbol(b, Decl(iteratorZip.ts, 92, 37)) +>a : Symbol(a, Decl(iteratorZip.ts, 90, 31)) +>b : Symbol(b, Decl(iteratorZip.ts, 90, 39)) >undefined : Symbol(undefined) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const e: { a: number; }[] = d; ->e : Symbol(e, Decl(iteratorZip.ts, 93, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 93, 10)) ->d : Symbol(d, Decl(iteratorZip.ts, 92, 5)) +const a33: { a: number; }[] = a32; +>a33 : Symbol(a33, Decl(iteratorZip.ts, 91, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 91, 12)) +>a32 : Symbol(a32, Decl(iteratorZip.ts, 90, 5)) -d[0].b; ->d : Symbol(d, Decl(iteratorZip.ts, 92, 5)) +a32[0].b; +>a32 : Symbol(a32, Decl(iteratorZip.ts, 90, 5)) -const f: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); ->f : Symbol(f, Decl(iteratorZip.ts, 95, 5)) +const a34: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); +>a34 : Symbol(a34, Decl(iteratorZip.ts, 93, 5)) >Iterator.zipKeyed({ a: undefined }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 95, 38)) +>a : Symbol(a, Decl(iteratorZip.ts, 93, 40)) >undefined : Symbol(undefined) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const g: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); ->g : Symbol(g, Decl(iteratorZip.ts, 96, 5)) +const a35: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); +>a35 : Symbol(a35, Decl(iteratorZip.ts, 94, 5)) >Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 96, 38)) +>a : Symbol(a, Decl(iteratorZip.ts, 94, 40)) >undefined : Symbol(undefined) ->mode : Symbol(mode, Decl(iteratorZip.ts, 96, 56)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 96, 73)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 94, 58)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 94, 75)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -interface I { ->I : Symbol(I, Decl(iteratorZip.ts, 96, 99)) +interface I2 { +>I2 : Symbol(I2, Decl(iteratorZip.ts, 94, 101)) readonly a: Iterable; ->a : Symbol(I.a, Decl(iteratorZip.ts, 98, 13)) +>a : Symbol(I2.a, Decl(iteratorZip.ts, 96, 14)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) readonly b?: Iterator; ->b : Symbol(I.b, Decl(iteratorZip.ts, 99, 33)) +>b : Symbol(I2.b, Decl(iteratorZip.ts, 97, 33)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) readonly c: Iterable | undefined; ->c : Symbol(I.c, Decl(iteratorZip.ts, 100, 34)) +>c : Symbol(I2.c, Decl(iteratorZip.ts, 98, 34)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) readonly d?: undefined; ->d : Symbol(I.d, Decl(iteratorZip.ts, 101, 46)) +>d : Symbol(I2.d, Decl(iteratorZip.ts, 99, 46)) } -declare const h: I; ->h : Symbol(h, Decl(iteratorZip.ts, 104, 13)) ->I : Symbol(I, Decl(iteratorZip.ts, 96, 99)) +declare const a36: I2; +>a36 : Symbol(a36, Decl(iteratorZip.ts, 102, 13)) +>I2 : Symbol(I2, Decl(iteratorZip.ts, 94, 101)) -const i = Iterator.zipKeyed(h).toArray(); ->i : Symbol(i, Decl(iteratorZip.ts, 105, 5)) ->Iterator.zipKeyed(h).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a37 = Iterator.zipKeyed(a36).toArray(); +>a37 : Symbol(a37, Decl(iteratorZip.ts, 103, 5)) +>Iterator.zipKeyed(a36).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->h : Symbol(h, Decl(iteratorZip.ts, 104, 13)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const j: { a: number; b?: string; c?: boolean; }[] = i; ->j : Symbol(j, Decl(iteratorZip.ts, 106, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 106, 10)) ->b : Symbol(b, Decl(iteratorZip.ts, 106, 21)) ->c : Symbol(c, Decl(iteratorZip.ts, 106, 33)) ->i : Symbol(i, Decl(iteratorZip.ts, 105, 5)) - -i[0].a = 2; ->i[0].a : Symbol(a, Decl(iteratorZip.ts, 98, 13)) ->i : Symbol(i, Decl(iteratorZip.ts, 105, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 98, 13)) - -i[0].b = "a"; ->i[0].b : Symbol(b, Decl(iteratorZip.ts, 99, 33)) ->i : Symbol(i, Decl(iteratorZip.ts, 105, 5)) ->b : Symbol(b, Decl(iteratorZip.ts, 99, 33)) - -i[0].c = true; ->i[0].c : Symbol(c, Decl(iteratorZip.ts, 100, 34)) ->i : Symbol(i, Decl(iteratorZip.ts, 105, 5)) ->c : Symbol(c, Decl(iteratorZip.ts, 100, 34)) - -i[0].d; ->i : Symbol(i, Decl(iteratorZip.ts, 105, 5)) - -const k: { a: number; c: boolean; }[] = i; ->k : Symbol(k, Decl(iteratorZip.ts, 111, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 111, 10)) ->c : Symbol(c, Decl(iteratorZip.ts, 111, 21)) ->i : Symbol(i, Decl(iteratorZip.ts, 105, 5)) - -const l: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); ->l : Symbol(l, Decl(iteratorZip.ts, 112, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 112, 10)) ->b : Symbol(b, Decl(iteratorZip.ts, 112, 33)) ->c : Symbol(c, Decl(iteratorZip.ts, 112, 57)) ->Iterator.zipKeyed(h, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>a36 : Symbol(a36, Decl(iteratorZip.ts, 102, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a38: { a: number; b?: string; c?: boolean; }[] = a37; +>a38 : Symbol(a38, Decl(iteratorZip.ts, 104, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 104, 12)) +>b : Symbol(b, Decl(iteratorZip.ts, 104, 23)) +>c : Symbol(c, Decl(iteratorZip.ts, 104, 35)) +>a37 : Symbol(a37, Decl(iteratorZip.ts, 103, 5)) + +a37[0].a = 2; +>a37[0].a : Symbol(a, Decl(iteratorZip.ts, 96, 14)) +>a37 : Symbol(a37, Decl(iteratorZip.ts, 103, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 96, 14)) + +a37[0].b = "a"; +>a37[0].b : Symbol(b, Decl(iteratorZip.ts, 97, 33)) +>a37 : Symbol(a37, Decl(iteratorZip.ts, 103, 5)) +>b : Symbol(b, Decl(iteratorZip.ts, 97, 33)) + +a37[0].c = true; +>a37[0].c : Symbol(c, Decl(iteratorZip.ts, 98, 34)) +>a37 : Symbol(a37, Decl(iteratorZip.ts, 103, 5)) +>c : Symbol(c, Decl(iteratorZip.ts, 98, 34)) + +a37[0].d; +>a37 : Symbol(a37, Decl(iteratorZip.ts, 103, 5)) + +const a39: { a: number; c: boolean; }[] = a37; +>a39 : Symbol(a39, Decl(iteratorZip.ts, 109, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 109, 12)) +>c : Symbol(c, Decl(iteratorZip.ts, 109, 23)) +>a37 : Symbol(a37, Decl(iteratorZip.ts, 103, 5)) + +const a40: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(a36, { mode: "longest" }).toArray(); +>a40 : Symbol(a40, Decl(iteratorZip.ts, 110, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 110, 12)) +>b : Symbol(b, Decl(iteratorZip.ts, 110, 35)) +>c : Symbol(c, Decl(iteratorZip.ts, 110, 59)) +>Iterator.zipKeyed(a36, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->h : Symbol(h, Decl(iteratorZip.ts, 104, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 112, 111)) +>a36 : Symbol(a36, Decl(iteratorZip.ts, 102, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 110, 115)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -declare const m: { a: Iterable; } | { b: Iterator; }; ->m : Symbol(m, Decl(iteratorZip.ts, 114, 13)) ->a : Symbol(a, Decl(iteratorZip.ts, 114, 18)) +declare const a41: { a: Iterable; } | { b: Iterator; }; +>a41 : Symbol(a41, Decl(iteratorZip.ts, 112, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 112, 20)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->b : Symbol(b, Decl(iteratorZip.ts, 114, 45)) +>b : Symbol(b, Decl(iteratorZip.ts, 112, 47)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) -const n: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(m).toArray(); ->n : Symbol(n, Decl(iteratorZip.ts, 115, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 115, 11)) ->b : Symbol(b, Decl(iteratorZip.ts, 115, 28)) ->Iterator.zipKeyed(m).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a42: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(a41).toArray(); +>a42 : Symbol(a42, Decl(iteratorZip.ts, 113, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 113, 13)) +>b : Symbol(b, Decl(iteratorZip.ts, 113, 30)) +>Iterator.zipKeyed(a41).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->m : Symbol(m, Decl(iteratorZip.ts, 114, 13)) +>a41 : Symbol(a41, Decl(iteratorZip.ts, 112, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -declare const o: { a: Iterable; } | { b: number; }; ->o : Symbol(o, Decl(iteratorZip.ts, 116, 13)) ->a : Symbol(a, Decl(iteratorZip.ts, 116, 18)) +declare const a43: { a: Iterable; } | { b: number; }; +>a43 : Symbol(a43, Decl(iteratorZip.ts, 114, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 114, 20)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->b : Symbol(b, Decl(iteratorZip.ts, 116, 45)) +>b : Symbol(b, Decl(iteratorZip.ts, 114, 47)) -Iterator.zipKeyed(o); +Iterator.zipKeyed(a43); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->o : Symbol(o, Decl(iteratorZip.ts, 116, 13)) +>a43 : Symbol(a43, Decl(iteratorZip.ts, 114, 13)) -Iterator.zipKeyed(o, { mode: "longest" }); +Iterator.zipKeyed(a43, { mode: "longest" }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->o : Symbol(o, Decl(iteratorZip.ts, 116, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 118, 22)) +>a43 : Symbol(a43, Decl(iteratorZip.ts, 114, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 116, 24)) -Iterator.zipKeyed(o, { mode: "longest", padding: {} }); +Iterator.zipKeyed(a43, { mode: "longest", padding: {} }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->o : Symbol(o, Decl(iteratorZip.ts, 116, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 119, 22)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 119, 39)) +>a43 : Symbol(a43, Decl(iteratorZip.ts, 114, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 117, 24)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 117, 41)) -declare const p: { a?: Iterable; } | { b: string; }; ->p : Symbol(p, Decl(iteratorZip.ts, 120, 13)) ->a : Symbol(a, Decl(iteratorZip.ts, 120, 18)) +declare const a44: { a?: Iterable; } | { b: string; }; +>a44 : Symbol(a44, Decl(iteratorZip.ts, 118, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 118, 20)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->b : Symbol(b, Decl(iteratorZip.ts, 120, 46)) +>b : Symbol(b, Decl(iteratorZip.ts, 118, 48)) -Iterator.zipKeyed(p); +Iterator.zipKeyed(a44); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->p : Symbol(p, Decl(iteratorZip.ts, 120, 13)) +>a44 : Symbol(a44, Decl(iteratorZip.ts, 118, 13)) -declare const q: { a: Iterable; } | { b: undefined; }; ->q : Symbol(q, Decl(iteratorZip.ts, 122, 13)) ->a : Symbol(a, Decl(iteratorZip.ts, 122, 18)) +declare const a45: { a: Iterable; } | { b: undefined; }; +>a45 : Symbol(a45, Decl(iteratorZip.ts, 120, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 120, 20)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->b : Symbol(b, Decl(iteratorZip.ts, 122, 45)) +>b : Symbol(b, Decl(iteratorZip.ts, 120, 47)) -const r: { a: number; }[] = Iterator.zipKeyed(q).toArray(); ->r : Symbol(r, Decl(iteratorZip.ts, 123, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 123, 10)) ->Iterator.zipKeyed(q).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a46: { a: number; }[] = Iterator.zipKeyed(a45).toArray(); +>a46 : Symbol(a46, Decl(iteratorZip.ts, 121, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 121, 12)) +>Iterator.zipKeyed(a45).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->q : Symbol(q, Decl(iteratorZip.ts, 122, 13)) +>a45 : Symbol(a45, Decl(iteratorZip.ts, 120, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -declare const s: unique symbol; ->s : Symbol(s, Decl(iteratorZip.ts, 125, 13)) +declare const a47: unique symbol; +>a47 : Symbol(a47, Decl(iteratorZip.ts, 123, 13)) -declare const t: { a: Iterable; [s]?: Iterable; }; ->t : Symbol(t, Decl(iteratorZip.ts, 126, 13)) ->a : Symbol(a, Decl(iteratorZip.ts, 126, 18)) +declare const a48: { a: Iterable; [a47]?: Iterable; }; +>a48 : Symbol(a48, Decl(iteratorZip.ts, 124, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 124, 20)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->[s] : Symbol([s], Decl(iteratorZip.ts, 126, 39)) ->s : Symbol(s, Decl(iteratorZip.ts, 125, 13)) +>[a47] : Symbol([a47], Decl(iteratorZip.ts, 124, 41)) +>a47 : Symbol(a47, Decl(iteratorZip.ts, 123, 13)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) -const u: { a: number; [s]?: string; }[] = Iterator.zipKeyed(t).toArray(); ->u : Symbol(u, Decl(iteratorZip.ts, 127, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 127, 10)) ->[s] : Symbol([s], Decl(iteratorZip.ts, 127, 21)) ->s : Symbol(s, Decl(iteratorZip.ts, 125, 13)) ->Iterator.zipKeyed(t).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a49: { a: number; [a47]?: string; }[] = Iterator.zipKeyed(a48).toArray(); +>a49 : Symbol(a49, Decl(iteratorZip.ts, 125, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 125, 12)) +>[a47] : Symbol([a47], Decl(iteratorZip.ts, 125, 23)) +>a47 : Symbol(a47, Decl(iteratorZip.ts, 123, 13)) +>Iterator.zipKeyed(a48).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->t : Symbol(t, Decl(iteratorZip.ts, 126, 13)) +>a48 : Symbol(a48, Decl(iteratorZip.ts, 124, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) Iterator.zipKeyed({ a: [1], b: null }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 129, 19)) ->b : Symbol(b, Decl(iteratorZip.ts, 129, 27)) +>a : Symbol(a, Decl(iteratorZip.ts, 127, 19)) +>b : Symbol(b, Decl(iteratorZip.ts, 127, 27)) Iterator.zipKeyed({ a: [1], b: false }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 130, 19)) ->b : Symbol(b, Decl(iteratorZip.ts, 130, 27)) +>a : Symbol(a, Decl(iteratorZip.ts, 128, 19)) +>b : Symbol(b, Decl(iteratorZip.ts, 128, 27)) Iterator.zip([undefined]); >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) @@ -672,658 +674,725 @@ Iterator.zip([undefined]); >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >undefined : Symbol(undefined) -declare const v: { a?: undefined; }; ->v : Symbol(v, Decl(iteratorZip.ts, 133, 13)) ->a : Symbol(a, Decl(iteratorZip.ts, 133, 18)) +declare const a50: { a?: undefined; }; +>a50 : Symbol(a50, Decl(iteratorZip.ts, 131, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 131, 20)) -const w: never[] = Iterator.zipKeyed(v).toArray(); ->w : Symbol(w, Decl(iteratorZip.ts, 134, 5)) ->Iterator.zipKeyed(v).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a51: never[] = Iterator.zipKeyed(a50).toArray(); +>a51 : Symbol(a51, Decl(iteratorZip.ts, 132, 5)) +>Iterator.zipKeyed(a50).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->v : Symbol(v, Decl(iteratorZip.ts, 133, 13)) +>a50 : Symbol(a50, Decl(iteratorZip.ts, 131, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const x: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); ->x : Symbol(x, Decl(iteratorZip.ts, 135, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 135, 10)) +const a52: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); +>a52 : Symbol(a52, Decl(iteratorZip.ts, 133, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 133, 12)) >Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 135, 47)) ->b : Symbol(b, Decl(iteratorZip.ts, 135, 55)) +>a : Symbol(a, Decl(iteratorZip.ts, 133, 49)) +>b : Symbol(b, Decl(iteratorZip.ts, 133, 57)) >undefined : Symbol(undefined) ->mode : Symbol(mode, Decl(iteratorZip.ts, 135, 73)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 135, 90)) ->a : Symbol(a, Decl(iteratorZip.ts, 135, 101)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 133, 75)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 133, 92)) +>a : Symbol(a, Decl(iteratorZip.ts, 133, 103)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const y: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); ->y : Symbol(y, Decl(iteratorZip.ts, 136, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 136, 10)) +const a53: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); +>a53 : Symbol(a53, Decl(iteratorZip.ts, 134, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 134, 12)) >Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 136, 59)) ->b : Symbol(b, Decl(iteratorZip.ts, 136, 67)) +>a : Symbol(a, Decl(iteratorZip.ts, 134, 61)) +>b : Symbol(b, Decl(iteratorZip.ts, 134, 69)) >undefined : Symbol(undefined) ->mode : Symbol(mode, Decl(iteratorZip.ts, 136, 85)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 134, 87)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) function f1(a: Iterable) { ->f1 : Symbol(f1, Decl(iteratorZip.ts, 136, 115)) ->T : Symbol(T, Decl(iteratorZip.ts, 138, 12)) ->a : Symbol(a, Decl(iteratorZip.ts, 138, 15)) +>f1 : Symbol(f1, Decl(iteratorZip.ts, 134, 117)) +>T : Symbol(T, Decl(iteratorZip.ts, 136, 12)) +>a : Symbol(a, Decl(iteratorZip.ts, 136, 15)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->T : Symbol(T, Decl(iteratorZip.ts, 138, 12)) +>T : Symbol(T, Decl(iteratorZip.ts, 136, 12)) const b: { a: T; }[] = Iterator.zipKeyed({ a }).toArray(); ->b : Symbol(b, Decl(iteratorZip.ts, 139, 9)) ->a : Symbol(a, Decl(iteratorZip.ts, 139, 14)) ->T : Symbol(T, Decl(iteratorZip.ts, 138, 12)) +>b : Symbol(b, Decl(iteratorZip.ts, 137, 9)) +>a : Symbol(a, Decl(iteratorZip.ts, 137, 14)) +>T : Symbol(T, Decl(iteratorZip.ts, 136, 12)) >Iterator.zipKeyed({ a }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 139, 46)) +>a : Symbol(a, Decl(iteratorZip.ts, 137, 46)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const c: [T][] = Iterator.zip([a]).toArray(); ->c : Symbol(c, Decl(iteratorZip.ts, 140, 9)) ->T : Symbol(T, Decl(iteratorZip.ts, 138, 12)) +>c : Symbol(c, Decl(iteratorZip.ts, 138, 9)) +>T : Symbol(T, Decl(iteratorZip.ts, 136, 12)) >Iterator.zip([a]).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->a : Symbol(a, Decl(iteratorZip.ts, 138, 15)) +>a : Symbol(a, Decl(iteratorZip.ts, 136, 15)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) return { b, c }; ->b : Symbol(b, Decl(iteratorZip.ts, 141, 12)) ->c : Symbol(c, Decl(iteratorZip.ts, 141, 15)) +>b : Symbol(b, Decl(iteratorZip.ts, 139, 12)) +>c : Symbol(c, Decl(iteratorZip.ts, 139, 15)) } -// Padding - -const paddingA: [Iterable, ...Iterable[]] = [[1, 2], [3]]; ->paddingA : Symbol(paddingA, Decl(iteratorZip.ts, 146, 5)) +const a54: [Iterable, ...Iterable[]] = [[1, 2], [3]]; +>a54 : Symbol(a54, Decl(iteratorZip.ts, 142, 5)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) -const paddingB = Iterator.zip(paddingA, { mode: "longest", padding: [0] }).toArray(); ->paddingB : Symbol(paddingB, Decl(iteratorZip.ts, 147, 5)) ->Iterator.zip(paddingA, { mode: "longest", padding: [0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a55 = Iterator.zip(a54, { mode: "longest", padding: [0] }).toArray(); +>a55 : Symbol(a55, Decl(iteratorZip.ts, 143, 5)) +>Iterator.zip(a54, { mode: "longest", padding: [0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->paddingA : Symbol(paddingA, Decl(iteratorZip.ts, 146, 5)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 147, 41)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 147, 58)) +>a54 : Symbol(a54, Decl(iteratorZip.ts, 142, 5)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 143, 31)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 143, 48)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const paddingC: (number | undefined)[][] = paddingB; ->paddingC : Symbol(paddingC, Decl(iteratorZip.ts, 148, 5)) ->paddingB : Symbol(paddingB, Decl(iteratorZip.ts, 147, 5)) +const a56: (number | undefined)[][] = a55; +>a56 : Symbol(a56, Decl(iteratorZip.ts, 144, 5)) +>a55 : Symbol(a55, Decl(iteratorZip.ts, 143, 5)) -const paddingD: number[][] = paddingB; ->paddingD : Symbol(paddingD, Decl(iteratorZip.ts, 149, 5)) ->paddingB : Symbol(paddingB, Decl(iteratorZip.ts, 147, 5)) +const a57: number[][] = a55; +>a57 : Symbol(a57, Decl(iteratorZip.ts, 145, 5)) +>a55 : Symbol(a55, Decl(iteratorZip.ts, 143, 5)) -const paddingE: Record> = { a: [1], b: [2, 3] }; ->paddingE : Symbol(paddingE, Decl(iteratorZip.ts, 151, 5)) +const a58: Record> = { a: [1], b: [2, 3] }; +>a58 : Symbol(a58, Decl(iteratorZip.ts, 147, 5)) >Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 151, 52)) ->b : Symbol(b, Decl(iteratorZip.ts, 151, 60)) +>a : Symbol(a, Decl(iteratorZip.ts, 147, 47)) +>b : Symbol(b, Decl(iteratorZip.ts, 147, 55)) -const paddingF = Iterator.zipKeyed(paddingE, { mode: "longest", padding: {} }).toArray(); ->paddingF : Symbol(paddingF, Decl(iteratorZip.ts, 152, 5)) ->Iterator.zipKeyed(paddingE, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a59 = Iterator.zipKeyed(a58, { mode: "longest", padding: {} }).toArray(); +>a59 : Symbol(a59, Decl(iteratorZip.ts, 148, 5)) +>Iterator.zipKeyed(a58, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->paddingE : Symbol(paddingE, Decl(iteratorZip.ts, 151, 5)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 152, 46)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 152, 63)) +>a58 : Symbol(a58, Decl(iteratorZip.ts, 147, 5)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 148, 36)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 148, 53)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const paddingG: Record[] = paddingF; ->paddingG : Symbol(paddingG, Decl(iteratorZip.ts, 153, 5)) +const a60: Record[] = a59; +>a60 : Symbol(a60, Decl(iteratorZip.ts, 149, 5)) >Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) ->paddingF : Symbol(paddingF, Decl(iteratorZip.ts, 152, 5)) +>a59 : Symbol(a59, Decl(iteratorZip.ts, 148, 5)) -const paddingH: Record[] = paddingF; ->paddingH : Symbol(paddingH, Decl(iteratorZip.ts, 154, 5)) +const a61: Record[] = a59; +>a61 : Symbol(a61, Decl(iteratorZip.ts, 150, 5)) >Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) ->paddingF : Symbol(paddingF, Decl(iteratorZip.ts, 152, 5)) +>a59 : Symbol(a59, Decl(iteratorZip.ts, 148, 5)) -declare const paddingI: Record; ->paddingI : Symbol(paddingI, Decl(iteratorZip.ts, 156, 13)) +declare const a62: Record; +>a62 : Symbol(a62, Decl(iteratorZip.ts, 152, 13)) >Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) -const paddingJ = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: paddingI }).toArray(); ->paddingJ : Symbol(paddingJ, Decl(iteratorZip.ts, 157, 5)) ->Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: paddingI }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a63 = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a62 }).toArray(); +>a63 : Symbol(a63, Decl(iteratorZip.ts, 153, 5)) +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a62 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 157, 36)) ->b : Symbol(b, Decl(iteratorZip.ts, 157, 44)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 157, 59)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 157, 76)) ->paddingI : Symbol(paddingI, Decl(iteratorZip.ts, 156, 13)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const paddingK: { a: number | undefined; b: number | undefined; }[] = paddingJ; ->paddingK : Symbol(paddingK, Decl(iteratorZip.ts, 158, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 158, 17)) ->b : Symbol(b, Decl(iteratorZip.ts, 158, 40)) ->paddingJ : Symbol(paddingJ, Decl(iteratorZip.ts, 157, 5)) - -const paddingL: { a: number; b: number; }[] = paddingJ; ->paddingL : Symbol(paddingL, Decl(iteratorZip.ts, 159, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 159, 17)) ->b : Symbol(b, Decl(iteratorZip.ts, 159, 28)) ->paddingJ : Symbol(paddingJ, Decl(iteratorZip.ts, 157, 5)) - -const paddingM = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); ->paddingM : Symbol(paddingM, Decl(iteratorZip.ts, 161, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 153, 31)) +>b : Symbol(b, Decl(iteratorZip.ts, 153, 39)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 153, 54)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 153, 71)) +>a62 : Symbol(a62, Decl(iteratorZip.ts, 152, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a64: { a: number | undefined; b: number | undefined; }[] = a63; +>a64 : Symbol(a64, Decl(iteratorZip.ts, 154, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 154, 12)) +>b : Symbol(b, Decl(iteratorZip.ts, 154, 35)) +>a63 : Symbol(a63, Decl(iteratorZip.ts, 153, 5)) + +const a65: { a: number; b: number; }[] = a63; +>a65 : Symbol(a65, Decl(iteratorZip.ts, 155, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 155, 12)) +>b : Symbol(b, Decl(iteratorZip.ts, 155, 23)) +>a63 : Symbol(a63, Decl(iteratorZip.ts, 153, 5)) + +const a66 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); +>a66 : Symbol(a66, Decl(iteratorZip.ts, 157, 5)) >Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 161, 45)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 161, 62)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 157, 40)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 157, 57)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const paddingN: [number, string][] = paddingM; ->paddingN : Symbol(paddingN, Decl(iteratorZip.ts, 162, 5)) ->paddingM : Symbol(paddingM, Decl(iteratorZip.ts, 161, 5)) +const a67: [number, string][] = a66; +>a67 : Symbol(a67, Decl(iteratorZip.ts, 158, 5)) +>a66 : Symbol(a66, Decl(iteratorZip.ts, 157, 5)) -const paddingO = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); ->paddingO : Symbol(paddingO, Decl(iteratorZip.ts, 163, 5)) +const a68 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); +>a68 : Symbol(a68, Decl(iteratorZip.ts, 159, 5)) >Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 163, 36)) ->b : Symbol(b, Decl(iteratorZip.ts, 163, 44)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 163, 58)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 163, 75)) ->a : Symbol(a, Decl(iteratorZip.ts, 163, 86)) ->b : Symbol(b, Decl(iteratorZip.ts, 163, 92)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const paddingP: { a: number; b: string; }[] = paddingO; ->paddingP : Symbol(paddingP, Decl(iteratorZip.ts, 164, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 164, 17)) ->b : Symbol(b, Decl(iteratorZip.ts, 164, 28)) ->paddingO : Symbol(paddingO, Decl(iteratorZip.ts, 163, 5)) - -const paddingQ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); ->paddingQ : Symbol(paddingQ, Decl(iteratorZip.ts, 166, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 159, 31)) +>b : Symbol(b, Decl(iteratorZip.ts, 159, 39)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 159, 53)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 159, 70)) +>a : Symbol(a, Decl(iteratorZip.ts, 159, 81)) +>b : Symbol(b, Decl(iteratorZip.ts, 159, 87)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a69: { a: number; b: string; }[] = a68; +>a69 : Symbol(a69, Decl(iteratorZip.ts, 160, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 160, 12)) +>b : Symbol(b, Decl(iteratorZip.ts, 160, 23)) +>a68 : Symbol(a68, Decl(iteratorZip.ts, 159, 5)) + +const a70 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); +>a70 : Symbol(a70, Decl(iteratorZip.ts, 162, 5)) >Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 166, 45)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 166, 62)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 162, 40)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 162, 57)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const paddingR: [number | undefined, string | undefined][] = paddingQ; ->paddingR : Symbol(paddingR, Decl(iteratorZip.ts, 167, 5)) ->paddingQ : Symbol(paddingQ, Decl(iteratorZip.ts, 166, 5)) +const a71: [number | undefined, string | undefined][] = a70; +>a71 : Symbol(a71, Decl(iteratorZip.ts, 163, 5)) +>a70 : Symbol(a70, Decl(iteratorZip.ts, 162, 5)) -const paddingS: [number, string][] = paddingQ; ->paddingS : Symbol(paddingS, Decl(iteratorZip.ts, 168, 5)) ->paddingQ : Symbol(paddingQ, Decl(iteratorZip.ts, 166, 5)) +const a72: [number, string][] = a70; +>a72 : Symbol(a72, Decl(iteratorZip.ts, 164, 5)) +>a70 : Symbol(a70, Decl(iteratorZip.ts, 162, 5)) -const paddingT = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); ->paddingT : Symbol(paddingT, Decl(iteratorZip.ts, 169, 5)) +const a73 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); +>a73 : Symbol(a73, Decl(iteratorZip.ts, 165, 5)) >Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 169, 36)) ->b : Symbol(b, Decl(iteratorZip.ts, 169, 44)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 169, 58)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 169, 75)) ->a : Symbol(a, Decl(iteratorZip.ts, 169, 86)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const paddingU: { a: number | undefined; b: string | undefined; }[] = paddingT; ->paddingU : Symbol(paddingU, Decl(iteratorZip.ts, 170, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 170, 17)) ->b : Symbol(b, Decl(iteratorZip.ts, 170, 40)) ->paddingT : Symbol(paddingT, Decl(iteratorZip.ts, 169, 5)) - -const paddingV: { a: number; b: string; }[] = paddingT; ->paddingV : Symbol(paddingV, Decl(iteratorZip.ts, 171, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 171, 17)) ->b : Symbol(b, Decl(iteratorZip.ts, 171, 28)) ->paddingT : Symbol(paddingT, Decl(iteratorZip.ts, 169, 5)) - -declare const paddingW: readonly [number, string]; ->paddingW : Symbol(paddingW, Decl(iteratorZip.ts, 173, 13)) - -const paddingX: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingW }).toArray(); ->paddingX : Symbol(paddingX, Decl(iteratorZip.ts, 174, 5)) ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingW }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 165, 31)) +>b : Symbol(b, Decl(iteratorZip.ts, 165, 39)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 165, 53)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 165, 70)) +>a : Symbol(a, Decl(iteratorZip.ts, 165, 81)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a74: { a: number | undefined; b: string | undefined; }[] = a73; +>a74 : Symbol(a74, Decl(iteratorZip.ts, 166, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 166, 12)) +>b : Symbol(b, Decl(iteratorZip.ts, 166, 35)) +>a73 : Symbol(a73, Decl(iteratorZip.ts, 165, 5)) + +const a75: { a: number; b: string; }[] = a73; +>a75 : Symbol(a75, Decl(iteratorZip.ts, 167, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 167, 12)) +>b : Symbol(b, Decl(iteratorZip.ts, 167, 23)) +>a73 : Symbol(a73, Decl(iteratorZip.ts, 165, 5)) + +declare const a76: readonly [number, string]; +>a76 : Symbol(a76, Decl(iteratorZip.ts, 169, 13)) + +const a77: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a76 }).toArray(); +>a77 : Symbol(a77, Decl(iteratorZip.ts, 170, 5)) +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: a76 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 174, 65)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 174, 82)) ->paddingW : Symbol(paddingW, Decl(iteratorZip.ts, 173, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 170, 60)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 170, 77)) +>a76 : Symbol(a76, Decl(iteratorZip.ts, 169, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -declare const paddingY: [number, string?]; ->paddingY : Symbol(paddingY, Decl(iteratorZip.ts, 175, 13)) +declare const a78: [number, string?]; +>a78 : Symbol(a78, Decl(iteratorZip.ts, 171, 13)) -const paddingZ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY }).toArray(); ->paddingZ : Symbol(paddingZ, Decl(iteratorZip.ts, 176, 5)) ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a79 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a78 }).toArray(); +>a79 : Symbol(a79, Decl(iteratorZip.ts, 172, 5)) +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: a78 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 176, 45)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 176, 62)) ->paddingY : Symbol(paddingY, Decl(iteratorZip.ts, 175, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 172, 40)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 172, 57)) +>a78 : Symbol(a78, Decl(iteratorZip.ts, 171, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const paddingA1: [number, string][] = paddingZ; ->paddingA1 : Symbol(paddingA1, Decl(iteratorZip.ts, 177, 5)) ->paddingZ : Symbol(paddingZ, Decl(iteratorZip.ts, 176, 5)) +const a80: [number, string][] = a79; +>a80 : Symbol(a80, Decl(iteratorZip.ts, 173, 5)) +>a79 : Symbol(a79, Decl(iteratorZip.ts, 172, 5)) -declare const paddingB1: [Iterable] | [Iterable, Iterable]; ->paddingB1 : Symbol(paddingB1, Decl(iteratorZip.ts, 179, 13)) +declare const a81: [Iterable] | [Iterable, Iterable]; +>a81 : Symbol(a81, Decl(iteratorZip.ts, 175, 13)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) -const paddingC1 = Iterator.zip(paddingB1, { mode: "longest", padding: [0] }).toArray(); ->paddingC1 : Symbol(paddingC1, Decl(iteratorZip.ts, 180, 5)) ->Iterator.zip(paddingB1, { mode: "longest", padding: [0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a82 = Iterator.zip(a81, { mode: "longest", padding: [0] }).toArray(); +>a82 : Symbol(a82, Decl(iteratorZip.ts, 176, 5)) +>Iterator.zip(a81, { mode: "longest", padding: [0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->paddingB1 : Symbol(paddingB1, Decl(iteratorZip.ts, 179, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 180, 43)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 180, 60)) +>a81 : Symbol(a81, Decl(iteratorZip.ts, 175, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 176, 31)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 176, 48)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const paddingD1: number[][] = paddingC1; ->paddingD1 : Symbol(paddingD1, Decl(iteratorZip.ts, 181, 5)) ->paddingC1 : Symbol(paddingC1, Decl(iteratorZip.ts, 180, 5)) +const a83: number[][] = a82; +>a83 : Symbol(a83, Decl(iteratorZip.ts, 177, 5)) +>a82 : Symbol(a82, Decl(iteratorZip.ts, 176, 5)) -declare const paddingE1: { a: Iterable; } | { b: Iterable; }; ->paddingE1 : Symbol(paddingE1, Decl(iteratorZip.ts, 182, 13)) ->a : Symbol(a, Decl(iteratorZip.ts, 182, 26)) +declare const a84: { a: Iterable; } | { b: Iterable; }; +>a84 : Symbol(a84, Decl(iteratorZip.ts, 178, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 178, 20)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->b : Symbol(b, Decl(iteratorZip.ts, 182, 53)) +>b : Symbol(b, Decl(iteratorZip.ts, 178, 47)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) -const paddingF1 = Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: 0 } }).toArray(); ->paddingF1 : Symbol(paddingF1, Decl(iteratorZip.ts, 183, 5)) ->Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a85 = Iterator.zipKeyed(a84, { mode: "longest", padding: { a: 0 } }).toArray(); +>a85 : Symbol(a85, Decl(iteratorZip.ts, 179, 5)) +>Iterator.zipKeyed(a84, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->paddingE1 : Symbol(paddingE1, Decl(iteratorZip.ts, 182, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 183, 48)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 183, 65)) ->a : Symbol(a, Decl(iteratorZip.ts, 183, 76)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const paddingG1: ({ a: number; } | { b: string; })[] = paddingF1; ->paddingG1 : Symbol(paddingG1, Decl(iteratorZip.ts, 184, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 184, 19)) ->b : Symbol(b, Decl(iteratorZip.ts, 184, 36)) ->paddingF1 : Symbol(paddingF1, Decl(iteratorZip.ts, 183, 5)) - -declare const paddingH1: { a: number; } | { b: string; }; ->paddingH1 : Symbol(paddingH1, Decl(iteratorZip.ts, 186, 13)) ->a : Symbol(a, Decl(iteratorZip.ts, 186, 26)) ->b : Symbol(b, Decl(iteratorZip.ts, 186, 43)) - -const paddingI1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: paddingH1 }).toArray(); ->paddingI1 : Symbol(paddingI1, Decl(iteratorZip.ts, 187, 5)) ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: paddingH1 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>a84 : Symbol(a84, Decl(iteratorZip.ts, 178, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 179, 36)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 179, 53)) +>a : Symbol(a, Decl(iteratorZip.ts, 179, 64)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a86: ({ a: number; } | { b: string; })[] = a85; +>a86 : Symbol(a86, Decl(iteratorZip.ts, 180, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 180, 13)) +>b : Symbol(b, Decl(iteratorZip.ts, 180, 30)) +>a85 : Symbol(a85, Decl(iteratorZip.ts, 179, 5)) + +declare const a87: { a: number; } | { b: string; }; +>a87 : Symbol(a87, Decl(iteratorZip.ts, 182, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 182, 20)) +>b : Symbol(b, Decl(iteratorZip.ts, 182, 37)) + +const a88 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: a87 }).toArray(); +>a88 : Symbol(a88, Decl(iteratorZip.ts, 183, 5)) +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: a87 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 187, 37)) ->b : Symbol(b, Decl(iteratorZip.ts, 187, 45)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 187, 59)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 187, 76)) ->paddingH1 : Symbol(paddingH1, Decl(iteratorZip.ts, 186, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 183, 31)) +>b : Symbol(b, Decl(iteratorZip.ts, 183, 39)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 183, 53)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 183, 70)) +>a87 : Symbol(a87, Decl(iteratorZip.ts, 182, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const paddingJ1: { a: number; b: string; }[] = paddingI1; ->paddingJ1 : Symbol(paddingJ1, Decl(iteratorZip.ts, 188, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 188, 18)) ->b : Symbol(b, Decl(iteratorZip.ts, 188, 29)) ->paddingI1 : Symbol(paddingI1, Decl(iteratorZip.ts, 187, 5)) +const a89: { a: number; b: string; }[] = a88; +>a89 : Symbol(a89, Decl(iteratorZip.ts, 184, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 184, 12)) +>b : Symbol(b, Decl(iteratorZip.ts, 184, 23)) +>a88 : Symbol(a88, Decl(iteratorZip.ts, 183, 5)) -const paddingK1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); ->paddingK1 : Symbol(paddingK1, Decl(iteratorZip.ts, 190, 5)) +const a90 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); +>a90 : Symbol(a90, Decl(iteratorZip.ts, 186, 5)) >Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 190, 37)) ->b : Symbol(b, Decl(iteratorZip.ts, 190, 45)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 190, 57)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 190, 74)) ->a : Symbol(a, Decl(iteratorZip.ts, 190, 85)) +>a : Symbol(a, Decl(iteratorZip.ts, 186, 31)) +>b : Symbol(b, Decl(iteratorZip.ts, 186, 39)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 186, 51)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 186, 68)) +>a : Symbol(a, Decl(iteratorZip.ts, 186, 79)) >undefined : Symbol(undefined) ->b : Symbol(b, Decl(iteratorZip.ts, 190, 99)) +>b : Symbol(b, Decl(iteratorZip.ts, 186, 93)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const paddingL1: { a: number; b: number; }[] = paddingK1; ->paddingL1 : Symbol(paddingL1, Decl(iteratorZip.ts, 191, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 191, 18)) ->b : Symbol(b, Decl(iteratorZip.ts, 191, 29)) ->paddingK1 : Symbol(paddingK1, Decl(iteratorZip.ts, 190, 5)) +const a91: { a: number; b: number; }[] = a90; +>a91 : Symbol(a91, Decl(iteratorZip.ts, 187, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 187, 12)) +>b : Symbol(b, Decl(iteratorZip.ts, 187, 23)) +>a90 : Symbol(a90, Decl(iteratorZip.ts, 186, 5)) -declare const paddingM1: { [K in `a${string}`]: Iterable; }; ->paddingM1 : Symbol(paddingM1, Decl(iteratorZip.ts, 193, 13)) ->K : Symbol(K, Decl(iteratorZip.ts, 193, 28)) +declare const a92: { [K in `a${string}`]: Iterable; }; +>a92 : Symbol(a92, Decl(iteratorZip.ts, 189, 13)) +>K : Symbol(K, Decl(iteratorZip.ts, 189, 22)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) -const paddingN1 = Iterator.zipKeyed(paddingM1, { mode: "longest", padding: {} }).toArray(); ->paddingN1 : Symbol(paddingN1, Decl(iteratorZip.ts, 194, 5)) ->Iterator.zipKeyed(paddingM1, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a93 = Iterator.zipKeyed(a92, { mode: "longest", padding: {} }).toArray(); +>a93 : Symbol(a93, Decl(iteratorZip.ts, 190, 5)) +>Iterator.zipKeyed(a92, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->paddingM1 : Symbol(paddingM1, Decl(iteratorZip.ts, 193, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 194, 48)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 194, 65)) +>a92 : Symbol(a92, Decl(iteratorZip.ts, 189, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 190, 36)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 190, 53)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const paddingO1: { [K in `a${string}`]: number; }[] = paddingN1; ->paddingO1 : Symbol(paddingO1, Decl(iteratorZip.ts, 195, 5)) ->K : Symbol(K, Decl(iteratorZip.ts, 195, 20)) ->paddingN1 : Symbol(paddingN1, Decl(iteratorZip.ts, 194, 5)) +const a94: { [K in `a${string}`]: number; }[] = a93; +>a94 : Symbol(a94, Decl(iteratorZip.ts, 191, 5)) +>K : Symbol(K, Decl(iteratorZip.ts, 191, 14)) +>a93 : Symbol(a93, Decl(iteratorZip.ts, 190, 5)) -declare const paddingP1: unique symbol; ->paddingP1 : Symbol(paddingP1, Decl(iteratorZip.ts, 197, 13)) +declare const a95: unique symbol; +>a95 : Symbol(a95, Decl(iteratorZip.ts, 193, 13)) -const paddingQ1: { [paddingP1]: number; }[] = Iterator.zipKeyed({ [paddingP1]: [1] }, { mode: "longest", padding: { [paddingP1]: 0 } }).toArray(); ->paddingQ1 : Symbol(paddingQ1, Decl(iteratorZip.ts, 198, 5)) ->[paddingP1] : Symbol([paddingP1], Decl(iteratorZip.ts, 198, 18)) ->paddingP1 : Symbol(paddingP1, Decl(iteratorZip.ts, 197, 13)) ->Iterator.zipKeyed({ [paddingP1]: [1] }, { mode: "longest", padding: { [paddingP1]: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a96: { [a95]: number; }[] = Iterator.zipKeyed({ [a95]: [1] }, { mode: "longest", padding: { [a95]: 0 } }).toArray(); +>a96 : Symbol(a96, Decl(iteratorZip.ts, 194, 5)) +>[a95] : Symbol([a95], Decl(iteratorZip.ts, 194, 12)) +>a95 : Symbol(a95, Decl(iteratorZip.ts, 193, 13)) +>Iterator.zipKeyed({ [a95]: [1] }, { mode: "longest", padding: { [a95]: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->[paddingP1] : Symbol([paddingP1], Decl(iteratorZip.ts, 198, 65)) ->paddingP1 : Symbol(paddingP1, Decl(iteratorZip.ts, 197, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 198, 87)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 198, 104)) ->[paddingP1] : Symbol([paddingP1], Decl(iteratorZip.ts, 198, 115)) ->paddingP1 : Symbol(paddingP1, Decl(iteratorZip.ts, 197, 13)) +>[a95] : Symbol([a95], Decl(iteratorZip.ts, 194, 53)) +>a95 : Symbol(a95, Decl(iteratorZip.ts, 193, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 194, 69)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 194, 86)) +>[a95] : Symbol([a95], Decl(iteratorZip.ts, 194, 97)) +>a95 : Symbol(a95, Decl(iteratorZip.ts, 193, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -declare const paddingR1: Record & { a: number; }; ->paddingR1 : Symbol(paddingR1, Decl(iteratorZip.ts, 200, 13)) +declare const a97: Record & { a: number; }; +>a97 : Symbol(a97, Decl(iteratorZip.ts, 196, 13)) >Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 200, 51)) +>a : Symbol(a, Decl(iteratorZip.ts, 196, 45)) -const paddingS1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: paddingR1 }).toArray(); ->paddingS1 : Symbol(paddingS1, Decl(iteratorZip.ts, 201, 5)) ->Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: paddingR1 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a98 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: a97 }).toArray(); +>a98 : Symbol(a98, Decl(iteratorZip.ts, 197, 5)) +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: a97 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 201, 37)) ->b : Symbol(b, Decl(iteratorZip.ts, 201, 45)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 201, 57)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 201, 74)) ->paddingR1 : Symbol(paddingR1, Decl(iteratorZip.ts, 200, 13)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -const paddingT1: { a: number; b: number | undefined; }[] = paddingS1; ->paddingT1 : Symbol(paddingT1, Decl(iteratorZip.ts, 202, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 202, 18)) ->b : Symbol(b, Decl(iteratorZip.ts, 202, 29)) ->paddingS1 : Symbol(paddingS1, Decl(iteratorZip.ts, 201, 5)) - -const paddingU1: { a: number; b: number; }[] = paddingS1; ->paddingU1 : Symbol(paddingU1, Decl(iteratorZip.ts, 203, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 203, 18)) ->b : Symbol(b, Decl(iteratorZip.ts, 203, 29)) ->paddingS1 : Symbol(paddingS1, Decl(iteratorZip.ts, 201, 5)) - -declare const paddingV1: [number] | [number, string]; ->paddingV1 : Symbol(paddingV1, Decl(iteratorZip.ts, 205, 13)) - -const paddingW1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingV1 }).toArray(); ->paddingW1 : Symbol(paddingW1, Decl(iteratorZip.ts, 206, 5)) ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingV1 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZip.ts, 197, 31)) +>b : Symbol(b, Decl(iteratorZip.ts, 197, 39)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 197, 51)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 197, 68)) +>a97 : Symbol(a97, Decl(iteratorZip.ts, 196, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a99: { a: number; b: number | undefined; }[] = a98; +>a99 : Symbol(a99, Decl(iteratorZip.ts, 198, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 198, 12)) +>b : Symbol(b, Decl(iteratorZip.ts, 198, 23)) +>a98 : Symbol(a98, Decl(iteratorZip.ts, 197, 5)) + +const a100: { a: number; b: number; }[] = a98; +>a100 : Symbol(a100, Decl(iteratorZip.ts, 199, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 199, 13)) +>b : Symbol(b, Decl(iteratorZip.ts, 199, 24)) +>a98 : Symbol(a98, Decl(iteratorZip.ts, 197, 5)) + +declare const a101: [number] | [number, string]; +>a101 : Symbol(a101, Decl(iteratorZip.ts, 201, 13)) + +const a102 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a101 }).toArray(); +>a102 : Symbol(a102, Decl(iteratorZip.ts, 202, 5)) +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: a101 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 206, 46)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 206, 63)) ->paddingV1 : Symbol(paddingV1, Decl(iteratorZip.ts, 205, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 202, 41)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 202, 58)) +>a101 : Symbol(a101, Decl(iteratorZip.ts, 201, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const paddingX1: [number, string | undefined][] = paddingW1; ->paddingX1 : Symbol(paddingX1, Decl(iteratorZip.ts, 207, 5)) ->paddingW1 : Symbol(paddingW1, Decl(iteratorZip.ts, 206, 5)) +const a103: [number, string | undefined][] = a102; +>a103 : Symbol(a103, Decl(iteratorZip.ts, 203, 5)) +>a102 : Symbol(a102, Decl(iteratorZip.ts, 202, 5)) -const paddingY1: [number, string][] = paddingW1; ->paddingY1 : Symbol(paddingY1, Decl(iteratorZip.ts, 208, 5)) ->paddingW1 : Symbol(paddingW1, Decl(iteratorZip.ts, 206, 5)) +const a104: [number, string][] = a102; +>a104 : Symbol(a104, Decl(iteratorZip.ts, 204, 5)) +>a102 : Symbol(a102, Decl(iteratorZip.ts, 202, 5)) -const paddingZ1: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); ->paddingZ1 : Symbol(paddingZ1, Decl(iteratorZip.ts, 210, 5)) +const a105: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); +>a105 : Symbol(a105, Decl(iteratorZip.ts, 206, 5)) >Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 210, 76)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 210, 93)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 206, 71)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 206, 88)) >undefined : Symbol(undefined) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const paddingA2: { a: number | undefined; b: number; }[] = paddingK1; ->paddingA2 : Symbol(paddingA2, Decl(iteratorZip.ts, 211, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 211, 18)) ->b : Symbol(b, Decl(iteratorZip.ts, 211, 41)) ->paddingK1 : Symbol(paddingK1, Decl(iteratorZip.ts, 190, 5)) - -// Own properties +const a106: { a: number | undefined; b: number; }[] = a90; +>a106 : Symbol(a106, Decl(iteratorZip.ts, 207, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 207, 13)) +>b : Symbol(b, Decl(iteratorZip.ts, 207, 36)) +>a90 : Symbol(a90, Decl(iteratorZip.ts, 186, 5)) -class InputsWithPrototypeMembers { ->InputsWithPrototypeMembers : Symbol(InputsWithPrototypeMembers, Decl(iteratorZip.ts, 211, 69)) +class C1 { +>C1 : Symbol(C1, Decl(iteratorZip.ts, 207, 58)) - values = [1, 2]; ->values : Symbol(InputsWithPrototypeMembers.values, Decl(iteratorZip.ts, 215, 34)) + a = [1, 2]; +>a : Symbol(C1.a, Decl(iteratorZip.ts, 209, 10)) - get label() { ->label : Symbol(InputsWithPrototypeMembers.label, Decl(iteratorZip.ts, 216, 20)) + get b() { +>b : Symbol(C1.b, Decl(iteratorZip.ts, 210, 15)) return "inputs"; } - describe() { ->describe : Symbol(InputsWithPrototypeMembers.describe, Decl(iteratorZip.ts, 220, 5)) + f() { +>f : Symbol(C1.f, Decl(iteratorZip.ts, 214, 5)) - return this.label; ->this.label : Symbol(InputsWithPrototypeMembers.label, Decl(iteratorZip.ts, 216, 20)) ->this : Symbol(InputsWithPrototypeMembers, Decl(iteratorZip.ts, 211, 69)) ->label : Symbol(InputsWithPrototypeMembers.label, Decl(iteratorZip.ts, 216, 20)) + return this.b; +>this.b : Symbol(C1.b, Decl(iteratorZip.ts, 210, 15)) +>this : Symbol(C1, Decl(iteratorZip.ts, 207, 58)) +>b : Symbol(C1.b, Decl(iteratorZip.ts, 210, 15)) } } -const instance = new InputsWithPrototypeMembers(); ->instance : Symbol(instance, Decl(iteratorZip.ts, 227, 5)) ->InputsWithPrototypeMembers : Symbol(InputsWithPrototypeMembers, Decl(iteratorZip.ts, 211, 69)) +const a107 = new C1(); +>a107 : Symbol(a107, Decl(iteratorZip.ts, 221, 5)) +>C1 : Symbol(C1, Decl(iteratorZip.ts, 207, 58)) -const inherited = Iterator.zipKeyed(instance).toArray(); ->inherited : Symbol(inherited, Decl(iteratorZip.ts, 228, 5)) ->Iterator.zipKeyed(instance).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a108 = Iterator.zipKeyed(a107).toArray(); +>a108 : Symbol(a108, Decl(iteratorZip.ts, 222, 5)) +>Iterator.zipKeyed(a107).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->instance : Symbol(instance, Decl(iteratorZip.ts, 227, 5)) +>a107 : Symbol(a107, Decl(iteratorZip.ts, 221, 5)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const inheritedStrict = Iterator.zipKeyed(instance, { mode: "strict" }).toArray(); ->inheritedStrict : Symbol(inheritedStrict, Decl(iteratorZip.ts, 229, 5)) ->Iterator.zipKeyed(instance, { mode: "strict" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a109 = Iterator.zipKeyed(a107, { mode: "strict" }).toArray(); +>a109 : Symbol(a109, Decl(iteratorZip.ts, 223, 5)) +>Iterator.zipKeyed(a107, { mode: "strict" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->instance : Symbol(instance, Decl(iteratorZip.ts, 227, 5)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 229, 53)) +>a107 : Symbol(a107, Decl(iteratorZip.ts, 221, 5)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 223, 38)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const inheritedLongest = Iterator.zipKeyed(instance, { mode: "longest" }).toArray(); ->inheritedLongest : Symbol(inheritedLongest, Decl(iteratorZip.ts, 230, 5)) ->Iterator.zipKeyed(instance, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a110 = Iterator.zipKeyed(a107, { mode: "longest" }).toArray(); +>a110 : Symbol(a110, Decl(iteratorZip.ts, 224, 5)) +>Iterator.zipKeyed(a107, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->instance : Symbol(instance, Decl(iteratorZip.ts, 227, 5)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 230, 54)) +>a107 : Symbol(a107, Decl(iteratorZip.ts, 221, 5)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 224, 38)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const inheritedPadded = Iterator.zipKeyed(instance, { mode: "longest", padding: { values: 0 } }).toArray(); ->inheritedPadded : Symbol(inheritedPadded, Decl(iteratorZip.ts, 231, 5)) ->Iterator.zipKeyed(instance, { mode: "longest", padding: { values: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a111 = Iterator.zipKeyed(a107, { mode: "longest", padding: { a: 0 } }).toArray(); +>a111 : Symbol(a111, Decl(iteratorZip.ts, 225, 5)) +>Iterator.zipKeyed(a107, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->instance : Symbol(instance, Decl(iteratorZip.ts, 227, 5)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 231, 53)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 231, 70)) ->values : Symbol(values, Decl(iteratorZip.ts, 231, 81)) +>a107 : Symbol(a107, Decl(iteratorZip.ts, 221, 5)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 225, 38)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 225, 55)) +>a : Symbol(a, Decl(iteratorZip.ts, 225, 66)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const hiddenInputs = { values: [1, 2], label: "inputs" }; ->hiddenInputs : Symbol(hiddenInputs, Decl(iteratorZip.ts, 233, 5)) ->values : Symbol(values, Decl(iteratorZip.ts, 233, 22)) ->label : Symbol(label, Decl(iteratorZip.ts, 233, 38)) +const a112 = { a: [1, 2], b: "inputs" }; +>a112 : Symbol(a112, Decl(iteratorZip.ts, 227, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 227, 14)) +>b : Symbol(b, Decl(iteratorZip.ts, 227, 25)) -Object.defineProperty(hiddenInputs, "label", { enumerable: false }); +Object.defineProperty(a112, "b", { enumerable: false }); >Object.defineProperty : Symbol(ObjectConstructor.defineProperty, Decl(lib.es5.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) >defineProperty : Symbol(ObjectConstructor.defineProperty, Decl(lib.es5.d.ts, --, --)) ->hiddenInputs : Symbol(hiddenInputs, Decl(iteratorZip.ts, 233, 5)) ->enumerable : Symbol(enumerable, Decl(iteratorZip.ts, 234, 46)) +>a112 : Symbol(a112, Decl(iteratorZip.ts, 227, 5)) +>enumerable : Symbol(enumerable, Decl(iteratorZip.ts, 228, 34)) -const nonEnumerable = Iterator.zipKeyed(hiddenInputs).toArray(); ->nonEnumerable : Symbol(nonEnumerable, Decl(iteratorZip.ts, 235, 5)) ->Iterator.zipKeyed(hiddenInputs).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a113 = Iterator.zipKeyed(a112).toArray(); +>a113 : Symbol(a113, Decl(iteratorZip.ts, 229, 5)) +>Iterator.zipKeyed(a112).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->hiddenInputs : Symbol(hiddenInputs, Decl(iteratorZip.ts, 233, 5)) +>a112 : Symbol(a112, Decl(iteratorZip.ts, 227, 5)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const nonEnumerablePadded = Iterator.zipKeyed(hiddenInputs, { mode: "longest", padding: { values: 0 } }).toArray(); ->nonEnumerablePadded : Symbol(nonEnumerablePadded, Decl(iteratorZip.ts, 236, 5)) ->Iterator.zipKeyed(hiddenInputs, { mode: "longest", padding: { values: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a114 = Iterator.zipKeyed(a112, { mode: "longest", padding: { a: 0 } }).toArray(); +>a114 : Symbol(a114, Decl(iteratorZip.ts, 230, 5)) +>Iterator.zipKeyed(a112, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->hiddenInputs : Symbol(hiddenInputs, Decl(iteratorZip.ts, 233, 5)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 236, 61)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 236, 78)) ->values : Symbol(values, Decl(iteratorZip.ts, 236, 89)) +>a112 : Symbol(a112, Decl(iteratorZip.ts, 227, 5)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 230, 38)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 230, 55)) +>a : Symbol(a, Decl(iteratorZip.ts, 230, 66)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -// The same static shape can have an enumerable non-iterator property instead. -// Such inputs are accepted by the fallback and checked at runtime. -const enumerableInputs = { values: [1, 2], label: "inputs" }; ->enumerableInputs : Symbol(enumerableInputs, Decl(iteratorZip.ts, 240, 5)) ->values : Symbol(values, Decl(iteratorZip.ts, 240, 26)) ->label : Symbol(label, Decl(iteratorZip.ts, 240, 42)) +const a115 = { a: [1, 2], b: "inputs" }; +>a115 : Symbol(a115, Decl(iteratorZip.ts, 232, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 232, 14)) +>b : Symbol(b, Decl(iteratorZip.ts, 232, 25)) -const enumerable = Iterator.zipKeyed(enumerableInputs).toArray(); ->enumerable : Symbol(enumerable, Decl(iteratorZip.ts, 241, 5)) ->Iterator.zipKeyed(enumerableInputs).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a116 = Iterator.zipKeyed(a115).toArray(); +>a116 : Symbol(a116, Decl(iteratorZip.ts, 233, 5)) +>Iterator.zipKeyed(a115).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->enumerableInputs : Symbol(enumerableInputs, Decl(iteratorZip.ts, 240, 5)) +>a115 : Symbol(a115, Decl(iteratorZip.ts, 232, 5)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -// The array's length and methods are not enumerable own properties. -const arrayInputs = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); ->arrayInputs : Symbol(arrayInputs, Decl(iteratorZip.ts, 244, 5)) +const a117 = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); +>a117 : Symbol(a117, Decl(iteratorZip.ts, 235, 5)) >Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -// The fallback must not claim that ignored properties exist on yielded objects. -const inheritedLabel: string = inherited[0].label; ->inheritedLabel : Symbol(inheritedLabel, Decl(iteratorZip.ts, 247, 5)) ->inherited : Symbol(inherited, Decl(iteratorZip.ts, 228, 5)) +const a118: string = a108[0].b; +>a118 : Symbol(a118, Decl(iteratorZip.ts, 237, 5)) +>a108 : Symbol(a108, Decl(iteratorZip.ts, 222, 5)) -const nonEnumerableLabel: string = nonEnumerable[0].label; ->nonEnumerableLabel : Symbol(nonEnumerableLabel, Decl(iteratorZip.ts, 248, 5)) ->nonEnumerable : Symbol(nonEnumerable, Decl(iteratorZip.ts, 235, 5)) +const a119: string = a113[0].b; +>a119 : Symbol(a119, Decl(iteratorZip.ts, 238, 5)) +>a113 : Symbol(a113, Decl(iteratorZip.ts, 229, 5)) -// Precise record inference still handles symbol keys and padding. -declare const ownKey: unique symbol; ->ownKey : Symbol(ownKey, Decl(iteratorZip.ts, 251, 13)) +declare const a120: unique symbol; +>a120 : Symbol(a120, Decl(iteratorZip.ts, 240, 13)) -const precise: { values: number; [ownKey]: string; }[] = Iterator.zipKeyed({ values: [1], [ownKey]: ["a"] }).toArray(); ->precise : Symbol(precise, Decl(iteratorZip.ts, 252, 5)) ->values : Symbol(values, Decl(iteratorZip.ts, 252, 16)) ->[ownKey] : Symbol([ownKey], Decl(iteratorZip.ts, 252, 32)) ->ownKey : Symbol(ownKey, Decl(iteratorZip.ts, 251, 13)) ->Iterator.zipKeyed({ values: [1], [ownKey]: ["a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a121: { a: number; [a120]: string; }[] = Iterator.zipKeyed({ a: [1], [a120]: ["a"] }).toArray(); +>a121 : Symbol(a121, Decl(iteratorZip.ts, 241, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 241, 13)) +>[a120] : Symbol([a120], Decl(iteratorZip.ts, 241, 24)) +>a120 : Symbol(a120, Decl(iteratorZip.ts, 240, 13)) +>Iterator.zipKeyed({ a: [1], [a120]: ["a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->values : Symbol(values, Decl(iteratorZip.ts, 252, 76)) ->[ownKey] : Symbol([ownKey], Decl(iteratorZip.ts, 252, 89)) ->ownKey : Symbol(ownKey, Decl(iteratorZip.ts, 251, 13)) +>a : Symbol(a, Decl(iteratorZip.ts, 241, 66)) +>[a120] : Symbol([a120], Decl(iteratorZip.ts, 241, 74)) +>a120 : Symbol(a120, Decl(iteratorZip.ts, 240, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const preciseLongest: { values: number | undefined; }[] = Iterator.zipKeyed({ values: [1] }, { mode: "longest" }).toArray(); ->preciseLongest : Symbol(preciseLongest, Decl(iteratorZip.ts, 253, 5)) ->values : Symbol(values, Decl(iteratorZip.ts, 253, 23)) ->Iterator.zipKeyed({ values: [1] }, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a122: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1] }, { mode: "longest" }).toArray(); +>a122 : Symbol(a122, Decl(iteratorZip.ts, 242, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 242, 13)) +>Iterator.zipKeyed({ a: [1] }, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->values : Symbol(values, Decl(iteratorZip.ts, 253, 77)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 253, 94)) +>a : Symbol(a, Decl(iteratorZip.ts, 242, 62)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 242, 74)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const precisePadded: { values: number; }[] = Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: 0 } }).toArray(); ->precisePadded : Symbol(precisePadded, Decl(iteratorZip.ts, 254, 5)) ->values : Symbol(values, Decl(iteratorZip.ts, 254, 22)) ->Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a123: { a: number; }[] = Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray(); +>a123 : Symbol(a123, Decl(iteratorZip.ts, 243, 5)) +>a : Symbol(a, Decl(iteratorZip.ts, 243, 13)) +>Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->values : Symbol(values, Decl(iteratorZip.ts, 254, 64)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 254, 81)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 254, 98)) ->values : Symbol(values, Decl(iteratorZip.ts, 254, 109)) +>a : Symbol(a, Decl(iteratorZip.ts, 243, 50)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 243, 62)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 243, 79)) +>a : Symbol(a, Decl(iteratorZip.ts, 243, 90)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) -const emptyOwnProperties: never[] = Iterator.zipKeyed({}).toArray(); ->emptyOwnProperties : Symbol(emptyOwnProperties, Decl(iteratorZip.ts, 255, 5)) ->Iterator.zipKeyed({}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +declare const a124: object; +>a124 : Symbol(a124, Decl(iteratorZip.ts, 245, 13)) + +const a125 = Iterator.zipKeyed(a124).toArray(); +>a125 : Symbol(a125, Decl(iteratorZip.ts, 246, 5)) +>Iterator.zipKeyed(a124).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a124 : Symbol(a124, Decl(iteratorZip.ts, 245, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +const a126 = Iterator.zipKeyed(a124, { mode: "strict" }).toArray(); +>a126 : Symbol(a126, Decl(iteratorZip.ts, 247, 5)) +>Iterator.zipKeyed(a124, { mode: "strict" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a124 : Symbol(a124, Decl(iteratorZip.ts, 245, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 247, 38)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a127 = Iterator.zipKeyed(a124, { mode: "longest" }).toArray(); +>a127 : Symbol(a127, Decl(iteratorZip.ts, 248, 5)) +>Iterator.zipKeyed(a124, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a124 : Symbol(a124, Decl(iteratorZip.ts, 245, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 248, 38)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a128 = Iterator.zipKeyed(a124, { mode: "longest", padding: { a: 0 } }).toArray(); +>a128 : Symbol(a128, Decl(iteratorZip.ts, 249, 5)) +>Iterator.zipKeyed(a124, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a124 : Symbol(a124, Decl(iteratorZip.ts, 245, 13)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 249, 38)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 249, 55)) +>a : Symbol(a, Decl(iteratorZip.ts, 249, 66)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a129: unknown = a125[0].a; +>a129 : Symbol(a129, Decl(iteratorZip.ts, 250, 5)) +>a125 : Symbol(a125, Decl(iteratorZip.ts, 246, 5)) + +const a130: unknown = a126[0].a; +>a130 : Symbol(a130, Decl(iteratorZip.ts, 251, 5)) +>a126 : Symbol(a126, Decl(iteratorZip.ts, 247, 5)) + +const a131: unknown = a127[0].a; +>a131 : Symbol(a131, Decl(iteratorZip.ts, 252, 5)) +>a127 : Symbol(a127, Decl(iteratorZip.ts, 248, 5)) + +const a132: unknown = a128[0].a; +>a132 : Symbol(a132, Decl(iteratorZip.ts, 253, 5)) +>a128 : Symbol(a128, Decl(iteratorZip.ts, 249, 5)) + +const a133: never[] = a125; +>a133 : Symbol(a133, Decl(iteratorZip.ts, 254, 5)) +>a125 : Symbol(a125, Decl(iteratorZip.ts, 246, 5)) + +declare const a134: {}; +>a134 : Symbol(a134, Decl(iteratorZip.ts, 256, 13)) + +const a135 = Iterator.zipKeyed(a134).toArray(); +>a135 : Symbol(a135, Decl(iteratorZip.ts, 257, 5)) +>Iterator.zipKeyed(a134).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a134 : Symbol(a134, Decl(iteratorZip.ts, 256, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a136: unknown = a135[0].a; +>a136 : Symbol(a136, Decl(iteratorZip.ts, 258, 5)) +>a135 : Symbol(a135, Decl(iteratorZip.ts, 257, 5)) + +const a137: never[] = a135; +>a137 : Symbol(a137, Decl(iteratorZip.ts, 259, 5)) +>a135 : Symbol(a135, Decl(iteratorZip.ts, 257, 5)) + Iterator.zipKeyed(0); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) @@ -1334,35 +1403,35 @@ Iterator.zipKeyed(null); >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) -Iterator.zipKeyed(instance, { mode: "invalid" }); +Iterator.zipKeyed(a107, { mode: "invalid" }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->instance : Symbol(instance, Decl(iteratorZip.ts, 227, 5)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 259, 29)) +>a107 : Symbol(a107, Decl(iteratorZip.ts, 221, 5)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 263, 25)) -Iterator.zipKeyed(instance, { mode: "shortest", padding: {} }); +Iterator.zipKeyed(a107, { mode: "shortest", padding: {} }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->instance : Symbol(instance, Decl(iteratorZip.ts, 227, 5)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 260, 29)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 260, 47)) +>a107 : Symbol(a107, Decl(iteratorZip.ts, 221, 5)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 264, 25)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 264, 43)) -Iterator.zipKeyed(instance, { mode: "longest", padding: 0 }); +Iterator.zipKeyed(a107, { mode: "longest", padding: 0 }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->instance : Symbol(instance, Decl(iteratorZip.ts, 227, 5)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 261, 29)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 261, 46)) +>a107 : Symbol(a107, Decl(iteratorZip.ts, 221, 5)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 265, 25)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 265, 42)) -Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: "invalid" } }); +Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: "invalid" } }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->values : Symbol(values, Decl(iteratorZip.ts, 262, 19)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 262, 36)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 262, 53)) ->values : Symbol(values, Decl(iteratorZip.ts, 262, 64)) +>a : Symbol(a, Decl(iteratorZip.ts, 266, 19)) +>mode : Symbol(mode, Decl(iteratorZip.ts, 266, 31)) +>padding : Symbol(padding, Decl(iteratorZip.ts, 266, 48)) +>a : Symbol(a, Decl(iteratorZip.ts, 266, 59)) diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).types b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).types index dc0aee2aaaaac..893dbca54cebd 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).types +++ b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).types @@ -1,11 +1,11 @@ //// [tests/cases/compiler/iteratorZip.ts] //// === iteratorZip.ts === -declare const key: unique symbol; ->key : unique symbol +declare const a1: unique symbol; +>a1 : unique symbol -const tuples: [number, string][] = Iterator.zip([ ->tuples : [number, string][] +const a2: [number, string][] = Iterator.zip([ +>a2 : [number, string][] >Iterator.zip([ [1, 2], new Set(["a", "b"]),] as const).toArray() : [1 | 2, string][] >Iterator.zip([ [1, 2], new Set(["a", "b"]),] as const).toArray : () => [1 | 2, string][] >Iterator.zip([ [1, 2], new Set(["a", "b"]),] as const) : IteratorObject<[1 | 2, string], undefined, unknown> @@ -30,17 +30,17 @@ const tuples: [number, string][] = Iterator.zip([ ] as const).toArray(); >toArray : () => [1 | 2, string][] -tuples[0][0] = 2; ->tuples[0][0] = 2 : 2 ->tuples[0][0] : number ->tuples[0] : [number, string] ->tuples : [number, string][] +a2[0][0] = 2; +>a2[0][0] = 2 : 2 +>a2[0][0] : number +>a2[0] : [number, string] +>a2 : [number, string][] >0 : 0 >0 : 0 >2 : 2 -const shortestTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray(); ->shortestTuples : [number, string][] +const a3: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray(); +>a3 : [number, string][] >Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray() : [1, "a"][] >Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray : () => [1, "a"][] >Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }) : IteratorObject<[1, "a"], undefined, unknown> @@ -58,8 +58,8 @@ const shortestTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { >"shortest" : "shortest" >toArray : () => [1, "a"][] -const strictTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray(); ->strictTuples : [number, string][] +const a4: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray(); +>a4 : [number, string][] >Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray() : [1, "a"][] >Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray : () => [1, "a"][] >Iterator.zip([[1], ["a"]] as const, { mode: "strict" }) : IteratorObject<[1, "a"], undefined, unknown> @@ -77,8 +77,8 @@ const strictTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { m >"strict" : "strict" >toArray : () => [1, "a"][] -const longestTuplesWithPadding: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray(); ->longestTuplesWithPadding : [number, string][] +const a5: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray(); +>a5 : [number, string][] >Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray() : [number, string][] >Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray : () => [number, string][] >Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }) : IteratorObject<[number, string], undefined, unknown> @@ -100,8 +100,8 @@ const longestTuplesWithPadding: [number, string][] = Iterator.zip([[1], ["a"]] a >"a" : "a" >toArray : () => [number, string][] -const longestTuplesWithoutPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray(); ->longestTuplesWithoutPadding : [number | undefined, string | undefined][] +const a6: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray(); +>a6 : [number | undefined, string | undefined][] >Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray() : [1 | undefined, "a" | undefined][] >Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray : () => [1 | undefined, "a" | undefined][] >Iterator.zip([[1], ["a"]] as const, { mode: "longest" }) : IteratorObject<[1 | undefined, "a" | undefined], undefined, unknown> @@ -119,8 +119,8 @@ const longestTuplesWithoutPadding: [number | undefined, string | undefined][] = >"longest" : "longest" >toArray : () => [1 | undefined, "a" | undefined][] -const longestTuplesWithPartialPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray(); ->longestTuplesWithPartialPadding : [number | undefined, string | undefined][] +const a7: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray(); +>a7 : [number | undefined, string | undefined][] >Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray() : [number, "a" | undefined][] >Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray : () => [number, "a" | undefined][] >Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }) : IteratorObject<[number, "a" | undefined], undefined, unknown> @@ -141,16 +141,16 @@ const longestTuplesWithPartialPadding: [number | undefined, string | undefined][ >1 : 1 >toArray : () => [number, "a" | undefined][] -declare const maybeLongestOptions: { mode: "shortest"; } | { mode: "longest"; }; ->maybeLongestOptions : { mode: "shortest"; } | { mode: "longest"; } +declare const a8: { mode: "shortest"; } | { mode: "longest"; }; +>a8 : { mode: "shortest"; } | { mode: "longest"; } >mode : "shortest" >mode : "longest" -const maybeLongestTuples: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray(); ->maybeLongestTuples : [number | undefined, string | undefined][] ->Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray() : [1 | undefined, "a" | undefined][] ->Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray : () => [1 | undefined, "a" | undefined][] ->Iterator.zip([[1], ["a"]] as const, maybeLongestOptions) : IteratorObject<[1 | undefined, "a" | undefined], undefined, unknown> +const a9: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, a8).toArray(); +>a9 : [number | undefined, string | undefined][] +>Iterator.zip([[1], ["a"]] as const, a8).toArray() : [1 | undefined, "a" | undefined][] +>Iterator.zip([[1], ["a"]] as const, a8).toArray : () => [1 | undefined, "a" | undefined][] +>Iterator.zip([[1], ["a"]] as const, a8) : IteratorObject<[1 | undefined, "a" | undefined], undefined, unknown> >Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor >zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } @@ -160,11 +160,11 @@ const maybeLongestTuples: [number | undefined, string | undefined][] = Iterator. >1 : 1 >["a"] : readonly ["a"] >"a" : "a" ->maybeLongestOptions : { mode: "shortest"; } | { mode: "longest"; } +>a8 : { mode: "shortest"; } | { mode: "longest"; } >toArray : () => [1 | undefined, "a" | undefined][] -const empty: never[] = Iterator.zip([]).toArray(); ->empty : never[] +const a10: never[] = Iterator.zip([]).toArray(); +>a10 : never[] >Iterator.zip([]).toArray() : never[] >Iterator.zip([]).toArray : () => never[] >Iterator.zip([]) : IteratorObject @@ -174,8 +174,8 @@ const empty: never[] = Iterator.zip([]).toArray(); >[] : [] >toArray : () => never[] -const emptyLongest: never[] = Iterator.zip([], { mode: "longest" }).toArray(); ->emptyLongest : never[] +const a11: never[] = Iterator.zip([], { mode: "longest" }).toArray(); +>a11 : never[] >Iterator.zip([], { mode: "longest" }).toArray() : never[] >Iterator.zip([], { mode: "longest" }).toArray : () => never[] >Iterator.zip([], { mode: "longest" }) : IteratorObject @@ -188,58 +188,58 @@ const emptyLongest: never[] = Iterator.zip([], { mode: "longest" }).toArray(); >"longest" : "longest" >toArray : () => never[] -declare const iterables: Iterable>; ->iterables : Iterable> +declare const a12: Iterable>; +>a12 : Iterable> -const arrays: number[][] = Iterator.zip(iterables).toArray(); ->arrays : number[][] ->Iterator.zip(iterables).toArray() : number[][] ->Iterator.zip(iterables).toArray : () => number[][] ->Iterator.zip(iterables) : IteratorObject +const a13: number[][] = Iterator.zip(a12).toArray(); +>a13 : number[][] +>Iterator.zip(a12).toArray() : number[][] +>Iterator.zip(a12).toArray : () => number[][] +>Iterator.zip(a12) : IteratorObject >Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor >zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->iterables : Iterable> +>a12 : Iterable> >toArray : () => number[][] -const longestArrays: (number | undefined)[][] = Iterator.zip(iterables, { mode: "longest" }).toArray(); ->longestArrays : (number | undefined)[][] ->Iterator.zip(iterables, { mode: "longest" }).toArray() : (number | undefined)[][] ->Iterator.zip(iterables, { mode: "longest" }).toArray : () => (number | undefined)[][] ->Iterator.zip(iterables, { mode: "longest" }) : IteratorObject<(number | undefined)[], undefined, unknown> +const a14: (number | undefined)[][] = Iterator.zip(a12, { mode: "longest" }).toArray(); +>a14 : (number | undefined)[][] +>Iterator.zip(a12, { mode: "longest" }).toArray() : (number | undefined)[][] +>Iterator.zip(a12, { mode: "longest" }).toArray : () => (number | undefined)[][] +>Iterator.zip(a12, { mode: "longest" }) : IteratorObject<(number | undefined)[], undefined, unknown> >Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor >zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->iterables : Iterable> +>a12 : Iterable> >{ mode: "longest" } : { mode: "longest"; } >mode : "longest" >"longest" : "longest" >toArray : () => (number | undefined)[][] -const maybeLongestArrays: (number | undefined)[][] = Iterator.zip(iterables, maybeLongestOptions).toArray(); ->maybeLongestArrays : (number | undefined)[][] ->Iterator.zip(iterables, maybeLongestOptions).toArray() : (number | undefined)[][] ->Iterator.zip(iterables, maybeLongestOptions).toArray : () => (number | undefined)[][] ->Iterator.zip(iterables, maybeLongestOptions) : IteratorObject<(number | undefined)[], undefined, unknown> +const a15: (number | undefined)[][] = Iterator.zip(a12, a8).toArray(); +>a15 : (number | undefined)[][] +>Iterator.zip(a12, a8).toArray() : (number | undefined)[][] +>Iterator.zip(a12, a8).toArray : () => (number | undefined)[][] +>Iterator.zip(a12, a8) : IteratorObject<(number | undefined)[], undefined, unknown> >Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor >zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->iterables : Iterable> ->maybeLongestOptions : { mode: "shortest"; } | { mode: "longest"; } +>a12 : Iterable> +>a8 : { mode: "shortest"; } | { mode: "longest"; } >toArray : () => (number | undefined)[][] -declare const iterableArray: Iterable[]; ->iterableArray : Iterable[] +declare const a16: Iterable[]; +>a16 : Iterable[] -const longestArrayWithPadding: (number | undefined)[][] = Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray(); ->longestArrayWithPadding : (number | undefined)[][] ->Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray() : (number | undefined)[][] ->Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray : () => (number | undefined)[][] ->Iterator.zip(iterableArray, { mode: "longest", padding: [] }) : IteratorObject<(number | undefined)[], undefined, unknown> +const a17: (number | undefined)[][] = Iterator.zip(a16, { mode: "longest", padding: [] }).toArray(); +>a17 : (number | undefined)[][] +>Iterator.zip(a16, { mode: "longest", padding: [] }).toArray() : (number | undefined)[][] +>Iterator.zip(a16, { mode: "longest", padding: [] }).toArray : () => (number | undefined)[][] +>Iterator.zip(a16, { mode: "longest", padding: [] }) : IteratorObject<(number | undefined)[], undefined, unknown> >Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor >zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->iterableArray : Iterable[] +>a16 : Iterable[] >{ mode: "longest", padding: [] } : { mode: "longest"; padding: []; } >mode : "longest" >"longest" : "longest" @@ -247,20 +247,20 @@ const longestArrayWithPadding: (number | undefined)[][] = Iterator.zip(iterableA >[] : [] >toArray : () => (number | undefined)[][] -const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ ->objects : { a: number; b: string; [key]: boolean; }[] +const a18: { a: number; b: string; [a1]: boolean; }[] = Iterator.zipKeyed({ +>a18 : { a: number; b: string; [a1]: boolean; }[] >a : number >b : string ->[key] : boolean ->key : unique symbol ->Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const).toArray() : { a: 1 | 2; b: string; [key]: boolean; }[] ->Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const).toArray : () => { a: 1 | 2; b: string; [key]: boolean; }[] ->Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const) : IteratorObject<{ a: 1 | 2; b: string; [key]: boolean; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>[a1] : boolean +>a1 : unique symbol +>Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [a1]: [true, false],} as const).toArray() : ({ a: 1 | 2; b: string; [a1]: boolean; } & {})[] +>Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [a1]: [true, false],} as const).toArray : () => ({ a: 1 | 2; b: string; [a1]: boolean; } & {})[] +>Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [a1]: [true, false],} as const) : IteratorObject<{ a: 1 | 2; b: string; [a1]: boolean; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->{ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} as const : { readonly a: readonly [1, 2]; readonly b: Set; readonly [key]: readonly [true, false]; } ->{ a: [1, 2], b: new Set(["a", "b"]), [key]: [true, false],} : { readonly a: readonly [1, 2]; readonly b: Set; readonly [key]: readonly [true, false]; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1, 2], b: new Set(["a", "b"]), [a1]: [true, false],} as const : { readonly a: readonly [1, 2]; readonly b: Set; readonly [a1]: readonly [true, false]; } +>{ a: [1, 2], b: new Set(["a", "b"]), [a1]: [true, false],} : { readonly a: readonly [1, 2]; readonly b: Set; readonly [a1]: readonly [true, false]; } a: [1, 2], >a : readonly [1, 2] @@ -276,35 +276,35 @@ const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ >"a" : "a" >"b" : "b" - [key]: [true, false], ->[key] : readonly [true, false] ->key : unique symbol + [a1]: [true, false], +>[a1] : readonly [true, false] +>a1 : unique symbol >[true, false] : readonly [true, false] >true : true >false : false } as const).toArray(); ->toArray : () => { a: 1 | 2; b: string; [key]: boolean; }[] +>toArray : () => ({ a: 1 | 2; b: string; [a1]: boolean; } & {})[] -objects[0].a = 2; ->objects[0].a = 2 : 2 ->objects[0].a : number ->objects[0] : { a: number; b: string; [key]: boolean; } ->objects : { a: number; b: string; [key]: boolean; }[] +a18[0].a = 2; +>a18[0].a = 2 : 2 +>a18[0].a : number +>a18[0] : { a: number; b: string; [a1]: boolean; } +>a18 : { a: number; b: string; [a1]: boolean; }[] >0 : 0 >a : number >2 : 2 -const longestObjectsWithPadding: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { ->longestObjectsWithPadding : { a: number; b: string; }[] +const a19: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +>a19 : { a: number; b: string; }[] >a : number >b : string ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}).toArray() : { a: number; b: string; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}).toArray : () => { a: number; b: string; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}) : IteratorObject<{ a: number; b: string; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}).toArray() : ({ a: number; b: string; } & {})[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}).toArray : () => ({ a: number; b: string; } & {})[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}) : IteratorObject<{ a: number; b: string; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >a : readonly [1] @@ -328,18 +328,18 @@ const longestObjectsWithPadding: { a: number; b: string; }[] = Iterator.zipKeyed >"a" : "a" }).toArray(); ->toArray : () => { a: number; b: string; }[] +>toArray : () => ({ a: number; b: string; } & {})[] -const longestObjectsWithoutPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { ->longestObjectsWithoutPadding : { a: number | undefined; b: string | undefined; }[] +const a20: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +>a20 : { a: number | undefined; b: string | undefined; }[] >a : number | undefined >b : string | undefined ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}).toArray() : { a: 1 | undefined; b: "a" | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}).toArray : () => { a: 1 | undefined; b: "a" | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}) : IteratorObject<{ a: 1 | undefined; b: "a" | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}).toArray() : ({ a: 1 | undefined; b: "a" | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}).toArray : () => ({ a: 1 | undefined; b: "a" | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}) : IteratorObject<{ a: 1 | undefined; b: "a" | undefined; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >a : readonly [1] @@ -355,18 +355,18 @@ const longestObjectsWithoutPadding: { a: number | undefined; b: string | undefin >"longest" : "longest" }).toArray(); ->toArray : () => { a: 1 | undefined; b: "a" | undefined; }[] +>toArray : () => ({ a: 1 | undefined; b: "a" | undefined; } & {})[] -const longestObjectsWithPartialPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { ->longestObjectsWithPartialPadding : { a: number | undefined; b: string | undefined; }[] +const a21: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +>a21 : { a: number | undefined; b: string | undefined; }[] >a : number | undefined >b : string | undefined ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}).toArray() : { a: 1 | undefined; b: string; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}).toArray : () => { a: 1 | undefined; b: string; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}) : IteratorObject<{ a: 1 | undefined; b: string; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}).toArray() : ({ a: 1 | undefined; b: string; } & {})[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}).toArray : () => ({ a: 1 | undefined; b: string; } & {})[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}) : IteratorObject<{ a: 1 | undefined; b: string; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >a : readonly [1] @@ -388,18 +388,18 @@ const longestObjectsWithPartialPadding: { a: number | undefined; b: string | und >"a" : "a" }).toArray(); ->toArray : () => { a: 1 | undefined; b: string; }[] +>toArray : () => ({ a: 1 | undefined; b: string; } & {})[] -const maybeLongestObjects: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray(); ->maybeLongestObjects : { a: number | undefined; b: string | undefined; }[] +const a22: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, a8).toArray(); +>a22 : { a: number | undefined; b: string | undefined; }[] >a : number | undefined >b : string | undefined ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray() : { a: 1 | undefined; b: "a" | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray : () => { a: 1 | undefined; b: "a" | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions) : IteratorObject<{ a: 1 | undefined; b: "a" | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, a8).toArray() : ({ a: 1 | undefined; b: "a" | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, a8).toArray : () => ({ a: 1 | undefined; b: "a" | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: ["a"] } as const, a8) : IteratorObject<{ a: 1 | undefined; b: "a" | undefined; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >a : readonly [1] @@ -408,10 +408,10 @@ const maybeLongestObjects: { a: number | undefined; b: string | undefined; }[] = >b : readonly ["a"] >["a"] : readonly ["a"] >"a" : "a" ->maybeLongestOptions : { mode: "shortest"; } | { mode: "longest"; } ->toArray : () => { a: 1 | undefined; b: "a" | undefined; }[] +>a8 : { mode: "shortest"; } | { mode: "longest"; } +>toArray : () => ({ a: 1 | undefined; b: "a" | undefined; } & {})[] -interface Inputs { +interface I1 { a: Iterable; >a : Iterable @@ -419,21 +419,21 @@ interface Inputs { >b : Iterator } -declare const inputs: Inputs; ->inputs : Inputs +declare const a23: I1; +>a23 : I1 -const rows: { a: number; b: string; }[] = Iterator.zipKeyed(inputs).toArray(); ->rows : { a: number; b: string; }[] +const a24: { a: number; b: string; }[] = Iterator.zipKeyed(a23).toArray(); +>a24 : { a: number; b: string; }[] >a : number >b : string ->Iterator.zipKeyed(inputs).toArray() : { a: number; b: string; }[] ->Iterator.zipKeyed(inputs).toArray : () => { a: number; b: string; }[] ->Iterator.zipKeyed(inputs) : IteratorObject<{ a: number; b: string; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed(a23).toArray() : ({ a: number; b: string; } & {})[] +>Iterator.zipKeyed(a23).toArray : () => ({ a: number; b: string; } & {})[] +>Iterator.zipKeyed(a23) : IteratorObject<{ a: number; b: string; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->inputs : Inputs ->toArray : () => { a: number; b: string; }[] +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a23 : I1 +>toArray : () => ({ a: number; b: string; } & {})[] Iterator.zip([[1]], { mode: "invalid" }); >Iterator.zip([[1]], { mode: "invalid" }) : IteratorObject @@ -489,59 +489,57 @@ Iterator.zip(0); Iterator.zipKeyed({ a: 0 }); >Iterator.zipKeyed({ a: 0 }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: 0 } : { a: number; } >a : number >0 : 0 -const emptyKeyed: never[] = Iterator.zipKeyed({}).toArray(); ->emptyKeyed : never[] ->Iterator.zipKeyed({}).toArray() : never[] ->Iterator.zipKeyed({}).toArray : () => never[] ->Iterator.zipKeyed({}) : IteratorObject ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a25: Record[] = Iterator.zipKeyed({}).toArray(); +>a25 : Record[] +>Iterator.zipKeyed({}).toArray() : Record[] +>Iterator.zipKeyed({}).toArray : () => Record[] +>Iterator.zipKeyed({}) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{} : {} ->toArray : () => never[] +>toArray : () => Record[] -const emptyKeyedLongest: never[] = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); ->emptyKeyedLongest : never[] ->Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray() : never[] ->Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray : () => never[] ->Iterator.zipKeyed({}, { mode: "longest", padding: {} }) : IteratorObject ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a26: Record[] = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); +>a26 : Record[] +>Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray() : Record[] +>Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray : () => Record[] +>Iterator.zipKeyed({}, { mode: "longest", padding: {} }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{} : {} >{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } >mode : "longest" >"longest" : "longest" >padding : {} >{} : {} ->toArray : () => never[] +>toArray : () => Record[] -declare const unionInputs: { a: Iterable; } | { b: Iterator; }; ->unionInputs : { a: Iterable; } | { b: Iterator; } +declare const a27: { a: Iterable; } | { b: Iterator; }; +>a27 : { a: Iterable; } | { b: Iterator; } >a : Iterable >b : Iterator -const unionRows: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(unionInputs).toArray(); ->unionRows : ({ a: number; } | { b: string; })[] +const a28: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(a27).toArray(); +>a28 : ({ a: number; } | { b: string; })[] >a : number >b : string ->Iterator.zipKeyed(unionInputs).toArray() : ({ a: number; } | { b: string; })[] ->Iterator.zipKeyed(unionInputs).toArray : () => ({ a: number; } | { b: string; })[] ->Iterator.zipKeyed(unionInputs) : IteratorObject<{ a: number; } | { b: string; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed(a27).toArray() : (({ a: number; } & {}) | ({ b: string; } & {}))[] +>Iterator.zipKeyed(a27).toArray : () => (({ a: number; } & {}) | ({ b: string; } & {}))[] +>Iterator.zipKeyed(a27) : IteratorObject<({ a: number; } & {}) | ({ b: string; } & {}), undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->unionInputs : { a: Iterable; } | { b: Iterator; } ->toArray : () => ({ a: number; } | { b: string; })[] - -// Inputs +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a27 : { a: Iterable; } | { b: Iterator; } +>toArray : () => (({ a: number; } & {}) | ({ b: string; } & {}))[] Iterator.zip("ab"); >Iterator.zip("ab") : IteratorObject @@ -569,17 +567,17 @@ Iterator.zip(new Set(["ab"])); >"ab" : "ab" Iterator.zipKeyed("ab"); ->Iterator.zipKeyed("ab") : IteratorObject ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed("ab") : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >"ab" : "ab" Iterator.zipKeyed({ a: "ab" }); >Iterator.zipKeyed({ a: "ab" }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: "ab" } : { a: string; } >a : string >"ab" : "ab" @@ -611,10 +609,10 @@ Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); >"ab" : "ab" Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); ->Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }) : IteratorObject ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{} : {} >{ mode: "longest", padding: "ab" } : { mode: "longest"; padding: string; } >mode : "longest" @@ -622,8 +620,8 @@ Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); >padding : string >"ab" : "ab" -const a: [string][] = Iterator.zip([new String("ab")]).toArray(); ->a : [string][] +const a29: [string][] = Iterator.zip([new String("ab")]).toArray(); +>a29 : [string][] >Iterator.zip([new String("ab")]).toArray() : [string][] >Iterator.zip([new String("ab")]).toArray : () => [string][] >Iterator.zip([new String("ab")]) : IteratorObject<[string], undefined, unknown> @@ -636,24 +634,24 @@ const a: [string][] = Iterator.zip([new String("ab")]).toArray(); >"ab" : "ab" >toArray : () => [string][] -const b: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); ->b : { a: string; }[] +const a30: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); +>a30 : { a: string; }[] >a : string ->Iterator.zipKeyed({ a: new String("ab") }).toArray() : { a: string; }[] ->Iterator.zipKeyed({ a: new String("ab") }).toArray : () => { a: string; }[] ->Iterator.zipKeyed({ a: new String("ab") }) : IteratorObject<{ a: string; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed({ a: new String("ab") }).toArray() : ({ a: string; } & {})[] +>Iterator.zipKeyed({ a: new String("ab") }).toArray : () => ({ a: string; } & {})[] +>Iterator.zipKeyed({ a: new String("ab") }) : IteratorObject<{ a: string; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: new String("ab") } : { a: String; } >a : String >new String("ab") : String >String : StringConstructor >"ab" : "ab" ->toArray : () => { a: string; }[] +>toArray : () => ({ a: string; } & {})[] -const c: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); ->c : (string | undefined)[][] +const a31: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); +>a31 : (string | undefined)[][] >Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray() : (string | undefined)[][] >Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray : () => (string | undefined)[][] >Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }) : IteratorObject<(string | undefined)[], undefined, unknown> @@ -672,55 +670,55 @@ const c: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", pad >"ab" : "ab" >toArray : () => (string | undefined)[][] -const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); ->d : { a: number; }[] ->Iterator.zipKeyed({ a: [1], b: undefined }).toArray() : { a: number; }[] ->Iterator.zipKeyed({ a: [1], b: undefined }).toArray : () => { a: number; }[] ->Iterator.zipKeyed({ a: [1], b: undefined }) : IteratorObject<{ a: number; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a32 = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); +>a32 : ({ a: number; } & {})[] +>Iterator.zipKeyed({ a: [1], b: undefined }).toArray() : ({ a: number; } & {})[] +>Iterator.zipKeyed({ a: [1], b: undefined }).toArray : () => ({ a: number; } & {})[] +>Iterator.zipKeyed({ a: [1], b: undefined }) : IteratorObject<{ a: number; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: [1], b: undefined } : { a: number[]; b: undefined; } >a : number[] >[1] : number[] >1 : 1 >b : undefined >undefined : undefined ->toArray : () => { a: number; }[] +>toArray : () => ({ a: number; } & {})[] -const e: { a: number; }[] = d; ->e : { a: number; }[] +const a33: { a: number; }[] = a32; +>a33 : { a: number; }[] >a : number ->d : { a: number; }[] +>a32 : ({ a: number; } & {})[] -d[0].b; ->d[0].b : any ->d[0] : { a: number; } ->d : { a: number; }[] +a32[0].b; +>a32[0].b : any +>a32[0] : { a: number; } & {} +>a32 : ({ a: number; } & {})[] >0 : 0 >b : any -const f: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); ->f : never[] +const a34: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); +>a34 : never[] >Iterator.zipKeyed({ a: undefined }).toArray() : never[] >Iterator.zipKeyed({ a: undefined }).toArray : () => never[] >Iterator.zipKeyed({ a: undefined }) : IteratorObject ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: undefined } : { a: undefined; } >a : undefined >undefined : undefined >toArray : () => never[] -const g: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); ->g : never[] +const a35: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); +>a35 : never[] >Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray() : never[] >Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray : () => never[] >Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }) : IteratorObject ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: undefined } : { a: undefined; } >a : undefined >undefined : undefined @@ -731,7 +729,7 @@ const g: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", paddin >{} : {} >toArray : () => never[] -interface I { +interface I2 { readonly a: Iterable; >a : Iterable @@ -744,193 +742,193 @@ interface I { readonly d?: undefined; >d : undefined } -declare const h: I; ->h : I - -const i = Iterator.zipKeyed(h).toArray(); ->i : { a: number; b?: string; c?: boolean; }[] ->Iterator.zipKeyed(h).toArray() : { a: number; b?: string; c?: boolean; }[] ->Iterator.zipKeyed(h).toArray : () => { a: number; b?: string; c?: boolean; }[] ->Iterator.zipKeyed(h) : IteratorObject<{ a: number; b?: string; c?: boolean; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->h : I ->toArray : () => { a: number; b?: string; c?: boolean; }[] - -const j: { a: number; b?: string; c?: boolean; }[] = i; ->j : { a: number; b?: string; c?: boolean; }[] +declare const a36: I2; +>a36 : I2 + +const a37 = Iterator.zipKeyed(a36).toArray(); +>a37 : ({ a: number; } & { b?: string; c?: boolean; })[] +>Iterator.zipKeyed(a36).toArray() : ({ a: number; } & { b?: string; c?: boolean; })[] +>Iterator.zipKeyed(a36).toArray : () => ({ a: number; } & { b?: string; c?: boolean; })[] +>Iterator.zipKeyed(a36) : IteratorObject<{ a: number; } & { b?: string; c?: boolean; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a36 : I2 +>toArray : () => ({ a: number; } & { b?: string; c?: boolean; })[] + +const a38: { a: number; b?: string; c?: boolean; }[] = a37; +>a38 : { a: number; b?: string; c?: boolean; }[] >a : number >b : string | undefined >c : boolean | undefined ->i : { a: number; b?: string; c?: boolean; }[] +>a37 : ({ a: number; } & { b?: string; c?: boolean; })[] -i[0].a = 2; ->i[0].a = 2 : 2 ->i[0].a : number ->i[0] : { a: number; b?: string; c?: boolean; } ->i : { a: number; b?: string; c?: boolean; }[] +a37[0].a = 2; +>a37[0].a = 2 : 2 +>a37[0].a : number +>a37[0] : { a: number; } & { b?: string; c?: boolean; } +>a37 : ({ a: number; } & { b?: string; c?: boolean; })[] >0 : 0 >a : number >2 : 2 -i[0].b = "a"; ->i[0].b = "a" : "a" ->i[0].b : string ->i[0] : { a: number; b?: string; c?: boolean; } ->i : { a: number; b?: string; c?: boolean; }[] +a37[0].b = "a"; +>a37[0].b = "a" : "a" +>a37[0].b : string +>a37[0] : { a: number; } & { b?: string; c?: boolean; } +>a37 : ({ a: number; } & { b?: string; c?: boolean; })[] >0 : 0 >b : string >"a" : "a" -i[0].c = true; ->i[0].c = true : true ->i[0].c : boolean ->i[0] : { a: number; b?: string; c?: boolean; } ->i : { a: number; b?: string; c?: boolean; }[] +a37[0].c = true; +>a37[0].c = true : true +>a37[0].c : boolean +>a37[0] : { a: number; } & { b?: string; c?: boolean; } +>a37 : ({ a: number; } & { b?: string; c?: boolean; })[] >0 : 0 >c : boolean >true : true -i[0].d; ->i[0].d : any ->i[0] : { a: number; b?: string; c?: boolean; } ->i : { a: number; b?: string; c?: boolean; }[] +a37[0].d; +>a37[0].d : any +>a37[0] : { a: number; } & { b?: string; c?: boolean; } +>a37 : ({ a: number; } & { b?: string; c?: boolean; })[] >0 : 0 >d : any -const k: { a: number; c: boolean; }[] = i; ->k : { a: number; c: boolean; }[] +const a39: { a: number; c: boolean; }[] = a37; +>a39 : { a: number; c: boolean; }[] >a : number >c : boolean ->i : { a: number; b?: string; c?: boolean; }[] +>a37 : ({ a: number; } & { b?: string; c?: boolean; })[] -const l: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); ->l : { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] +const a40: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(a36, { mode: "longest" }).toArray(); +>a40 : { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] >a : number | undefined >b : string | undefined >c : boolean | undefined ->Iterator.zipKeyed(h, { mode: "longest" }).toArray() : { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] ->Iterator.zipKeyed(h, { mode: "longest" }).toArray : () => { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] ->Iterator.zipKeyed(h, { mode: "longest" }) : IteratorObject<{ a: number | undefined; b?: string | undefined; c?: boolean | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed(a36, { mode: "longest" }).toArray() : ({ a: number | undefined; } & { b?: string | undefined; c?: boolean | undefined; })[] +>Iterator.zipKeyed(a36, { mode: "longest" }).toArray : () => ({ a: number | undefined; } & { b?: string | undefined; c?: boolean | undefined; })[] +>Iterator.zipKeyed(a36, { mode: "longest" }) : IteratorObject<{ a: number | undefined; } & { b?: string | undefined; c?: boolean | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->h : I +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a36 : I2 >{ mode: "longest" } : { mode: "longest"; } >mode : "longest" >"longest" : "longest" ->toArray : () => { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] +>toArray : () => ({ a: number | undefined; } & { b?: string | undefined; c?: boolean | undefined; })[] -declare const m: { a: Iterable; } | { b: Iterator; }; ->m : { a: Iterable; } | { b: Iterator; } +declare const a41: { a: Iterable; } | { b: Iterator; }; +>a41 : { a: Iterable; } | { b: Iterator; } >a : Iterable >b : Iterator -const n: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(m).toArray(); ->n : ({ a: number; } | { b: string; })[] +const a42: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(a41).toArray(); +>a42 : ({ a: number; } | { b: string; })[] >a : number >b : string ->Iterator.zipKeyed(m).toArray() : ({ a: number; } | { b: string; })[] ->Iterator.zipKeyed(m).toArray : () => ({ a: number; } | { b: string; })[] ->Iterator.zipKeyed(m) : IteratorObject<{ a: number; } | { b: string; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed(a41).toArray() : (({ a: number; } & {}) | ({ b: string; } & {}))[] +>Iterator.zipKeyed(a41).toArray : () => (({ a: number; } & {}) | ({ b: string; } & {}))[] +>Iterator.zipKeyed(a41) : IteratorObject<({ a: number; } & {}) | ({ b: string; } & {}), undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->m : { a: Iterable; } | { b: Iterator; } ->toArray : () => ({ a: number; } | { b: string; })[] +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a41 : { a: Iterable; } | { b: Iterator; } +>toArray : () => (({ a: number; } & {}) | ({ b: string; } & {}))[] -declare const o: { a: Iterable; } | { b: number; }; ->o : { a: Iterable; } | { b: number; } +declare const a43: { a: Iterable; } | { b: number; }; +>a43 : { a: Iterable; } | { b: number; } >a : Iterable >b : number -Iterator.zipKeyed(o); ->Iterator.zipKeyed(o) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +Iterator.zipKeyed(a43); +>Iterator.zipKeyed(a43) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->o : { a: Iterable; } | { b: number; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a43 : { a: Iterable; } | { b: number; } -Iterator.zipKeyed(o, { mode: "longest" }); ->Iterator.zipKeyed(o, { mode: "longest" }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +Iterator.zipKeyed(a43, { mode: "longest" }); +>Iterator.zipKeyed(a43, { mode: "longest" }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->o : { a: Iterable; } | { b: number; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a43 : { a: Iterable; } | { b: number; } >{ mode: "longest" } : { mode: "longest"; } >mode : "longest" >"longest" : "longest" -Iterator.zipKeyed(o, { mode: "longest", padding: {} }); ->Iterator.zipKeyed(o, { mode: "longest", padding: {} }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +Iterator.zipKeyed(a43, { mode: "longest", padding: {} }); +>Iterator.zipKeyed(a43, { mode: "longest", padding: {} }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->o : { a: Iterable; } | { b: number; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a43 : { a: Iterable; } | { b: number; } >{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } >mode : "longest" >"longest" : "longest" >padding : {} >{} : {} -declare const p: { a?: Iterable; } | { b: string; }; ->p : { a?: Iterable; } | { b: string; } +declare const a44: { a?: Iterable; } | { b: string; }; +>a44 : { a?: Iterable; } | { b: string; } >a : Iterable | undefined >b : string -Iterator.zipKeyed(p); ->Iterator.zipKeyed(p) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +Iterator.zipKeyed(a44); +>Iterator.zipKeyed(a44) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->p : { a?: Iterable; } | { b: string; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a44 : { a?: Iterable; } | { b: string; } -declare const q: { a: Iterable; } | { b: undefined; }; ->q : { a: Iterable; } | { b: undefined; } +declare const a45: { a: Iterable; } | { b: undefined; }; +>a45 : { a: Iterable; } | { b: undefined; } >a : Iterable >b : undefined -const r: { a: number; }[] = Iterator.zipKeyed(q).toArray(); ->r : { a: number; }[] +const a46: { a: number; }[] = Iterator.zipKeyed(a45).toArray(); +>a46 : { a: number; }[] >a : number ->Iterator.zipKeyed(q).toArray() : { a: number; }[] ->Iterator.zipKeyed(q).toArray : () => { a: number; }[] ->Iterator.zipKeyed(q) : IteratorObject<{ a: number; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed(a45).toArray() : ({ a: number; } & {})[] +>Iterator.zipKeyed(a45).toArray : () => ({ a: number; } & {})[] +>Iterator.zipKeyed(a45) : IteratorObject<{ a: number; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->q : { a: Iterable; } | { b: undefined; } ->toArray : () => { a: number; }[] +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a45 : { a: Iterable; } | { b: undefined; } +>toArray : () => ({ a: number; } & {})[] -declare const s: unique symbol; ->s : unique symbol +declare const a47: unique symbol; +>a47 : unique symbol -declare const t: { a: Iterable; [s]?: Iterable; }; ->t : { a: Iterable; [s]?: Iterable; } +declare const a48: { a: Iterable; [a47]?: Iterable; }; +>a48 : { a: Iterable; [a47]?: Iterable; } >a : Iterable ->[s] : Iterable | undefined ->s : unique symbol +>[a47] : Iterable | undefined +>a47 : unique symbol -const u: { a: number; [s]?: string; }[] = Iterator.zipKeyed(t).toArray(); ->u : { a: number; [s]?: string; }[] +const a49: { a: number; [a47]?: string; }[] = Iterator.zipKeyed(a48).toArray(); +>a49 : { a: number; [a47]?: string; }[] >a : number ->[s] : string | undefined ->s : unique symbol ->Iterator.zipKeyed(t).toArray() : { a: number; [s]?: string; }[] ->Iterator.zipKeyed(t).toArray : () => { a: number; [s]?: string; }[] ->Iterator.zipKeyed(t) : IteratorObject<{ a: number; [s]?: string; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>[a47] : string | undefined +>a47 : unique symbol +>Iterator.zipKeyed(a48).toArray() : ({ a: number; } & { [a47]?: string; })[] +>Iterator.zipKeyed(a48).toArray : () => ({ a: number; } & { [a47]?: string; })[] +>Iterator.zipKeyed(a48) : IteratorObject<{ a: number; } & { [a47]?: string; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->t : { a: Iterable; [s]?: Iterable; } ->toArray : () => { a: number; [s]?: string; }[] +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a48 : { a: Iterable; [a47]?: Iterable; } +>toArray : () => ({ a: number; } & { [a47]?: string; })[] Iterator.zipKeyed({ a: [1], b: null }); >Iterator.zipKeyed({ a: [1], b: null }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: [1], b: null } : { a: number[]; b: null; } >a : number[] >[1] : number[] @@ -939,9 +937,9 @@ Iterator.zipKeyed({ a: [1], b: null }); Iterator.zipKeyed({ a: [1], b: false }); >Iterator.zipKeyed({ a: [1], b: false }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: [1], b: false } : { a: number[]; b: false; } >a : number[] >[1] : number[] @@ -957,30 +955,30 @@ Iterator.zip([undefined]); >[undefined] : [undefined] >undefined : undefined -declare const v: { a?: undefined; }; ->v : { a?: undefined; } +declare const a50: { a?: undefined; }; +>a50 : { a?: undefined; } >a : undefined -const w: never[] = Iterator.zipKeyed(v).toArray(); ->w : never[] ->Iterator.zipKeyed(v).toArray() : never[] ->Iterator.zipKeyed(v).toArray : () => never[] ->Iterator.zipKeyed(v) : IteratorObject ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a51: never[] = Iterator.zipKeyed(a50).toArray(); +>a51 : never[] +>Iterator.zipKeyed(a50).toArray() : never[] +>Iterator.zipKeyed(a50).toArray : () => never[] +>Iterator.zipKeyed(a50) : IteratorObject +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->v : { a?: undefined; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a50 : { a?: undefined; } >toArray : () => never[] -const x: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); ->x : { a: number; }[] +const a52: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); +>a52 : { a: number; }[] >a : number ->Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray() : { a: number; }[] ->Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray : () => { a: number; }[] ->Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }) : IteratorObject<{ a: number; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray() : ({ a: number; } & {})[] +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray : () => ({ a: number; } & {})[] +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }) : IteratorObject<{ a: number; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: [1], b: undefined } : { a: number[]; b: undefined; } >a : number[] >[1] : number[] @@ -994,17 +992,17 @@ const x: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: >{ a: 0 } : { a: number; } >a : number >0 : 0 ->toArray : () => { a: number; }[] +>toArray : () => ({ a: number; } & {})[] -const y: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); ->y : { a: number | undefined; }[] +const a53: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); +>a53 : { a: number | undefined; }[] >a : number | undefined ->Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray() : { a: number | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray : () => { a: number | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }) : IteratorObject<{ a: number | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray() : ({ a: number | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray : () => ({ a: number | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }) : IteratorObject<{ a: number | undefined; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: [1], b: undefined } : { a: number[]; b: undefined; } >a : number[] >[1] : number[] @@ -1014,7 +1012,7 @@ const y: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined >{ mode: "longest" } : { mode: "longest"; } >mode : "longest" >"longest" : "longest" ->toArray : () => { a: number | undefined; }[] +>toArray : () => ({ a: number | undefined; } & {})[] function f1(a: Iterable) { >f1 : (a: Iterable) => { b: { a: T; }[]; c: [T][]; } @@ -1023,15 +1021,15 @@ function f1(a: Iterable) { const b: { a: T; }[] = Iterator.zipKeyed({ a }).toArray(); >b : { a: T; }[] >a : T ->Iterator.zipKeyed({ a }).toArray() : { a: T; }[] ->Iterator.zipKeyed({ a }).toArray : () => { a: T; }[] ->Iterator.zipKeyed({ a }) : IteratorObject<{ a: T; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K]; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K]; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K]; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed({ a }).toArray() : ({ a: T; } & {})[] +>Iterator.zipKeyed({ a }).toArray : () => ({ a: T; } & {})[] +>Iterator.zipKeyed({ a }) : IteratorObject<{ a: T; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K]; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K]; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T_1 as undefined extends T_1[K] ? never : K]: T_1[K]; } & { [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: T_1[K]; } extends infer T_2 ? { -readonly [K in keyof T_2]: (T_2[K] extends infer T_3 ? T_3 extends T_2[K] ? T_3 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a } : { a: Iterable; } >a : Iterable ->toArray : () => { a: T; }[] +>toArray : () => ({ a: T; } & {})[] const c: [T][] = Iterator.zip([a]).toArray(); >c : [T][] @@ -1051,10 +1049,8 @@ function f1(a: Iterable) { >c : [T][] } -// Padding - -const paddingA: [Iterable, ...Iterable[]] = [[1, 2], [3]]; ->paddingA : [Iterable, ...Iterable[]] +const a54: [Iterable, ...Iterable[]] = [[1, 2], [3]]; +>a54 : [Iterable, ...Iterable[]] >[[1, 2], [3]] : [number[], number[]] >[1, 2] : number[] >1 : 1 @@ -1062,15 +1058,15 @@ const paddingA: [Iterable, ...Iterable[]] = [[1, 2], [3]]; >[3] : number[] >3 : 3 -const paddingB = Iterator.zip(paddingA, { mode: "longest", padding: [0] }).toArray(); ->paddingB : [number, ...(number | undefined)[]][] ->Iterator.zip(paddingA, { mode: "longest", padding: [0] }).toArray() : [number, ...(number | undefined)[]][] ->Iterator.zip(paddingA, { mode: "longest", padding: [0] }).toArray : () => [number, ...(number | undefined)[]][] ->Iterator.zip(paddingA, { mode: "longest", padding: [0] }) : IteratorObject<[number, ...(number | undefined)[]], undefined, unknown> +const a55 = Iterator.zip(a54, { mode: "longest", padding: [0] }).toArray(); +>a55 : [number, ...(number | undefined)[]][] +>Iterator.zip(a54, { mode: "longest", padding: [0] }).toArray() : [number, ...(number | undefined)[]][] +>Iterator.zip(a54, { mode: "longest", padding: [0] }).toArray : () => [number, ...(number | undefined)[]][] +>Iterator.zip(a54, { mode: "longest", padding: [0] }) : IteratorObject<[number, ...(number | undefined)[]], undefined, unknown> >Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor >zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->paddingA : [Iterable, ...Iterable[]] +>a54 : [Iterable, ...Iterable[]] >{ mode: "longest", padding: [0] } : { mode: "longest"; padding: [number]; } >mode : "longest" >"longest" : "longest" @@ -1079,16 +1075,16 @@ const paddingB = Iterator.zip(paddingA, { mode: "longest", padding: [0] }).toArr >0 : 0 >toArray : () => [number, ...(number | undefined)[]][] -const paddingC: (number | undefined)[][] = paddingB; ->paddingC : (number | undefined)[][] ->paddingB : [number, ...(number | undefined)[]][] +const a56: (number | undefined)[][] = a55; +>a56 : (number | undefined)[][] +>a55 : [number, ...(number | undefined)[]][] -const paddingD: number[][] = paddingB; ->paddingD : number[][] ->paddingB : [number, ...(number | undefined)[]][] +const a57: number[][] = a55; +>a57 : number[][] +>a55 : [number, ...(number | undefined)[]][] -const paddingE: Record> = { a: [1], b: [2, 3] }; ->paddingE : Record> +const a58: Record> = { a: [1], b: [2, 3] }; +>a58 : Record> >{ a: [1], b: [2, 3] } : { a: number[]; b: number[]; } >a : number[] >[1] : number[] @@ -1098,41 +1094,41 @@ const paddingE: Record> = { a: [1], b: [2, 3] }; >2 : 2 >3 : 3 -const paddingF = Iterator.zipKeyed(paddingE, { mode: "longest", padding: {} }).toArray(); ->paddingF : { [x: string]: number | undefined; }[] ->Iterator.zipKeyed(paddingE, { mode: "longest", padding: {} }).toArray() : { [x: string]: number | undefined; }[] ->Iterator.zipKeyed(paddingE, { mode: "longest", padding: {} }).toArray : () => { [x: string]: number | undefined; }[] ->Iterator.zipKeyed(paddingE, { mode: "longest", padding: {} }) : IteratorObject<{ [x: string]: number | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a59 = Iterator.zipKeyed(a58, { mode: "longest", padding: {} }).toArray(); +>a59 : ({ [x: string]: number | undefined; } & {})[] +>Iterator.zipKeyed(a58, { mode: "longest", padding: {} }).toArray() : ({ [x: string]: number | undefined; } & {})[] +>Iterator.zipKeyed(a58, { mode: "longest", padding: {} }).toArray : () => ({ [x: string]: number | undefined; } & {})[] +>Iterator.zipKeyed(a58, { mode: "longest", padding: {} }) : IteratorObject<{ [x: string]: number | undefined; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->paddingE : Record> +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a58 : Record> >{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } >mode : "longest" >"longest" : "longest" >padding : {} >{} : {} ->toArray : () => { [x: string]: number | undefined; }[] +>toArray : () => ({ [x: string]: number | undefined; } & {})[] -const paddingG: Record[] = paddingF; ->paddingG : Record[] ->paddingF : { [x: string]: number | undefined; }[] +const a60: Record[] = a59; +>a60 : Record[] +>a59 : ({ [x: string]: number | undefined; } & {})[] -const paddingH: Record[] = paddingF; ->paddingH : Record[] ->paddingF : { [x: string]: number | undefined; }[] +const a61: Record[] = a59; +>a61 : Record[] +>a59 : ({ [x: string]: number | undefined; } & {})[] -declare const paddingI: Record; ->paddingI : Record +declare const a62: Record; +>a62 : Record -const paddingJ = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: paddingI }).toArray(); ->paddingJ : { a: number | undefined; b: number | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: paddingI }).toArray() : { a: number | undefined; b: number | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: paddingI }).toArray : () => { a: number | undefined; b: number | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: paddingI }) : IteratorObject<{ a: number | undefined; b: number | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a63 = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a62 }).toArray(); +>a63 : ({ a: number | undefined; b: number | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a62 }).toArray() : ({ a: number | undefined; b: number | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a62 }).toArray : () => ({ a: number | undefined; b: number | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a62 }) : IteratorObject<{ a: number | undefined; b: number | undefined; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: [1], b: [2, 3] } : { a: number[]; b: number[]; } >a : number[] >[1] : number[] @@ -1141,27 +1137,27 @@ const paddingJ = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", pad >[2, 3] : number[] >2 : 2 >3 : 3 ->{ mode: "longest", padding: paddingI } : { mode: "longest"; padding: Record; } +>{ mode: "longest", padding: a62 } : { mode: "longest"; padding: Record; } >mode : "longest" >"longest" : "longest" >padding : Record ->paddingI : Record ->toArray : () => { a: number | undefined; b: number | undefined; }[] +>a62 : Record +>toArray : () => ({ a: number | undefined; b: number | undefined; } & {})[] -const paddingK: { a: number | undefined; b: number | undefined; }[] = paddingJ; ->paddingK : { a: number | undefined; b: number | undefined; }[] +const a64: { a: number | undefined; b: number | undefined; }[] = a63; +>a64 : { a: number | undefined; b: number | undefined; }[] >a : number | undefined >b : number | undefined ->paddingJ : { a: number | undefined; b: number | undefined; }[] +>a63 : ({ a: number | undefined; b: number | undefined; } & {})[] -const paddingL: { a: number; b: number; }[] = paddingJ; ->paddingL : { a: number; b: number; }[] +const a65: { a: number; b: number; }[] = a63; +>a65 : { a: number; b: number; }[] >a : number >b : number ->paddingJ : { a: number | undefined; b: number | undefined; }[] +>a63 : ({ a: number | undefined; b: number | undefined; } & {})[] -const paddingM = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); ->paddingM : [number, string][] +const a66 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); +>a66 : [number, string][] >Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray() : [number, string][] >Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray : () => [number, string][] >Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }) : IteratorObject<[number, string], undefined, unknown> @@ -1182,18 +1178,18 @@ const paddingM = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] >"" : "" >toArray : () => [number, string][] -const paddingN: [number, string][] = paddingM; ->paddingN : [number, string][] ->paddingM : [number, string][] +const a67: [number, string][] = a66; +>a67 : [number, string][] +>a66 : [number, string][] -const paddingO = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); ->paddingO : { a: number; b: string; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray() : { a: number; b: string; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray : () => { a: number; b: string; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }) : IteratorObject<{ a: number; b: string; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a68 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); +>a68 : ({ a: number; b: string; } & {})[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray() : ({ a: number; b: string; } & {})[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray : () => ({ a: number; b: string; } & {})[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }) : IteratorObject<{ a: number; b: string; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } >a : number[] >[1] : number[] @@ -1210,16 +1206,16 @@ const paddingO = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padd >0 : 0 >b : string >"" : "" ->toArray : () => { a: number; b: string; }[] +>toArray : () => ({ a: number; b: string; } & {})[] -const paddingP: { a: number; b: string; }[] = paddingO; ->paddingP : { a: number; b: string; }[] +const a69: { a: number; b: string; }[] = a68; +>a69 : { a: number; b: string; }[] >a : number >b : string ->paddingO : { a: number; b: string; }[] +>a68 : ({ a: number; b: string; } & {})[] -const paddingQ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); ->paddingQ : [number, string | undefined][] +const a70 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); +>a70 : [number, string | undefined][] >Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray() : [number, string | undefined][] >Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray : () => [number, string | undefined][] >Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }) : IteratorObject<[number, string | undefined], undefined, unknown> @@ -1239,22 +1235,22 @@ const paddingQ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).t >0 : 0 >toArray : () => [number, string | undefined][] -const paddingR: [number | undefined, string | undefined][] = paddingQ; ->paddingR : [number | undefined, string | undefined][] ->paddingQ : [number, string | undefined][] +const a71: [number | undefined, string | undefined][] = a70; +>a71 : [number | undefined, string | undefined][] +>a70 : [number, string | undefined][] -const paddingS: [number, string][] = paddingQ; ->paddingS : [number, string][] ->paddingQ : [number, string | undefined][] +const a72: [number, string][] = a70; +>a72 : [number, string][] +>a70 : [number, string | undefined][] -const paddingT = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); ->paddingT : { a: number; b: string | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray() : { a: number; b: string | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray : () => { a: number; b: string | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }) : IteratorObject<{ a: number; b: string | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a73 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); +>a73 : ({ a: number; b: string | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray() : ({ a: number; b: string | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray : () => ({ a: number; b: string | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }) : IteratorObject<{ a: number; b: string | undefined; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } >a : number[] >[1] : number[] @@ -1269,28 +1265,28 @@ const paddingT = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padd >{ a: 0 } : { a: number; } >a : number >0 : 0 ->toArray : () => { a: number; b: string | undefined; }[] +>toArray : () => ({ a: number; b: string | undefined; } & {})[] -const paddingU: { a: number | undefined; b: string | undefined; }[] = paddingT; ->paddingU : { a: number | undefined; b: string | undefined; }[] +const a74: { a: number | undefined; b: string | undefined; }[] = a73; +>a74 : { a: number | undefined; b: string | undefined; }[] >a : number | undefined >b : string | undefined ->paddingT : { a: number; b: string | undefined; }[] +>a73 : ({ a: number; b: string | undefined; } & {})[] -const paddingV: { a: number; b: string; }[] = paddingT; ->paddingV : { a: number; b: string; }[] +const a75: { a: number; b: string; }[] = a73; +>a75 : { a: number; b: string; }[] >a : number >b : string ->paddingT : { a: number; b: string | undefined; }[] +>a73 : ({ a: number; b: string | undefined; } & {})[] -declare const paddingW: readonly [number, string]; ->paddingW : readonly [number, string] +declare const a76: readonly [number, string]; +>a76 : readonly [number, string] -const paddingX: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingW }).toArray(); ->paddingX : [number, string][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingW }).toArray() : [number, string][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingW }).toArray : () => [number, string][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingW }) : IteratorObject<[number, string], undefined, unknown> +const a77: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a76 }).toArray(); +>a77 : [number, string][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: a76 }).toArray() : [number, string][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: a76 }).toArray : () => [number, string][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: a76 }) : IteratorObject<[number, string], undefined, unknown> >Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor >zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } @@ -1299,21 +1295,21 @@ const paddingX: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest >1 : 1 >["a"] : string[] >"a" : "a" ->{ mode: "longest", padding: paddingW } : { mode: "longest"; padding: readonly [number, string]; } +>{ mode: "longest", padding: a76 } : { mode: "longest"; padding: readonly [number, string]; } >mode : "longest" >"longest" : "longest" >padding : readonly [number, string] ->paddingW : readonly [number, string] +>a76 : readonly [number, string] >toArray : () => [number, string][] -declare const paddingY: [number, string?]; ->paddingY : [number, string?] +declare const a78: [number, string?]; +>a78 : [number, string?] -const paddingZ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY }).toArray(); ->paddingZ : [number, string | undefined][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY }).toArray() : [number, string | undefined][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY }).toArray : () => [number, string | undefined][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY }) : IteratorObject<[number, string | undefined], undefined, unknown> +const a79 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a78 }).toArray(); +>a79 : [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: a78 }).toArray() : [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: a78 }).toArray : () => [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: a78 }) : IteratorObject<[number, string | undefined], undefined, unknown> >Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor >zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } @@ -1322,29 +1318,29 @@ const paddingZ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY >1 : 1 >["a"] : string[] >"a" : "a" ->{ mode: "longest", padding: paddingY } : { mode: "longest"; padding: [number, string?]; } +>{ mode: "longest", padding: a78 } : { mode: "longest"; padding: [number, string?]; } >mode : "longest" >"longest" : "longest" >padding : [number, string?] ->paddingY : [number, string?] +>a78 : [number, string?] >toArray : () => [number, string | undefined][] -const paddingA1: [number, string][] = paddingZ; ->paddingA1 : [number, string][] ->paddingZ : [number, string | undefined][] +const a80: [number, string][] = a79; +>a80 : [number, string][] +>a79 : [number, string | undefined][] -declare const paddingB1: [Iterable] | [Iterable, Iterable]; ->paddingB1 : [Iterable] | [Iterable, Iterable] +declare const a81: [Iterable] | [Iterable, Iterable]; +>a81 : [Iterable] | [Iterable, Iterable] -const paddingC1 = Iterator.zip(paddingB1, { mode: "longest", padding: [0] }).toArray(); ->paddingC1 : ([number] | [number, number | undefined])[] ->Iterator.zip(paddingB1, { mode: "longest", padding: [0] }).toArray() : ([number] | [number, number | undefined])[] ->Iterator.zip(paddingB1, { mode: "longest", padding: [0] }).toArray : () => ([number] | [number, number | undefined])[] ->Iterator.zip(paddingB1, { mode: "longest", padding: [0] }) : IteratorObject<[number] | [number, number | undefined], undefined, unknown> +const a82 = Iterator.zip(a81, { mode: "longest", padding: [0] }).toArray(); +>a82 : ([number] | [number, number | undefined])[] +>Iterator.zip(a81, { mode: "longest", padding: [0] }).toArray() : ([number] | [number, number | undefined])[] +>Iterator.zip(a81, { mode: "longest", padding: [0] }).toArray : () => ([number] | [number, number | undefined])[] +>Iterator.zip(a81, { mode: "longest", padding: [0] }) : IteratorObject<[number] | [number, number | undefined], undefined, unknown> >Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor >zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->paddingB1 : [Iterable] | [Iterable, Iterable] +>a81 : [Iterable] | [Iterable, Iterable] >{ mode: "longest", padding: [0] } : { mode: "longest"; padding: [number]; } >mode : "longest" >"longest" : "longest" @@ -1353,24 +1349,24 @@ const paddingC1 = Iterator.zip(paddingB1, { mode: "longest", padding: [0] }).toA >0 : 0 >toArray : () => ([number] | [number, number | undefined])[] -const paddingD1: number[][] = paddingC1; ->paddingD1 : number[][] ->paddingC1 : ([number] | [number, number | undefined])[] +const a83: number[][] = a82; +>a83 : number[][] +>a82 : ([number] | [number, number | undefined])[] -declare const paddingE1: { a: Iterable; } | { b: Iterable; }; ->paddingE1 : { a: Iterable; } | { b: Iterable; } +declare const a84: { a: Iterable; } | { b: Iterable; }; +>a84 : { a: Iterable; } | { b: Iterable; } >a : Iterable >b : Iterable -const paddingF1 = Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: 0 } }).toArray(); ->paddingF1 : ({ a: number; } | { b: string | undefined; })[] ->Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: 0 } }).toArray() : ({ a: number; } | { b: string | undefined; })[] ->Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: 0 } }).toArray : () => ({ a: number; } | { b: string | undefined; })[] ->Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: 0 } }) : IteratorObject<{ a: number; } | { b: string | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a85 = Iterator.zipKeyed(a84, { mode: "longest", padding: { a: 0 } }).toArray(); +>a85 : (({ a: number; } & {}) | ({ b: string | undefined; } & {}))[] +>Iterator.zipKeyed(a84, { mode: "longest", padding: { a: 0 } }).toArray() : (({ a: number; } & {}) | ({ b: string | undefined; } & {}))[] +>Iterator.zipKeyed(a84, { mode: "longest", padding: { a: 0 } }).toArray : () => (({ a: number; } & {}) | ({ b: string | undefined; } & {}))[] +>Iterator.zipKeyed(a84, { mode: "longest", padding: { a: 0 } }) : IteratorObject<({ a: number; } & {}) | ({ b: string | undefined; } & {}), undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->paddingE1 : { a: Iterable; } | { b: Iterable; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a84 : { a: Iterable; } | { b: Iterable; } >{ mode: "longest", padding: { a: 0 } } : { mode: "longest"; padding: { a: number; }; } >mode : "longest" >"longest" : "longest" @@ -1378,27 +1374,27 @@ const paddingF1 = Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: >{ a: 0 } : { a: number; } >a : number >0 : 0 ->toArray : () => ({ a: number; } | { b: string | undefined; })[] +>toArray : () => (({ a: number; } & {}) | ({ b: string | undefined; } & {}))[] -const paddingG1: ({ a: number; } | { b: string; })[] = paddingF1; ->paddingG1 : ({ a: number; } | { b: string; })[] +const a86: ({ a: number; } | { b: string; })[] = a85; +>a86 : ({ a: number; } | { b: string; })[] >a : number >b : string ->paddingF1 : ({ a: number; } | { b: string | undefined; })[] +>a85 : (({ a: number; } & {}) | ({ b: string | undefined; } & {}))[] -declare const paddingH1: { a: number; } | { b: string; }; ->paddingH1 : { a: number; } | { b: string; } +declare const a87: { a: number; } | { b: string; }; +>a87 : { a: number; } | { b: string; } >a : number >b : string -const paddingI1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: paddingH1 }).toArray(); ->paddingI1 : { a: number | undefined; b: string | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: paddingH1 }).toArray() : { a: number | undefined; b: string | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: paddingH1 }).toArray : () => { a: number | undefined; b: string | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: paddingH1 }) : IteratorObject<{ a: number | undefined; b: string | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a88 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: a87 }).toArray(); +>a88 : ({ a: number | undefined; b: string | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: a87 }).toArray() : ({ a: number | undefined; b: string | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: a87 }).toArray : () => ({ a: number | undefined; b: string | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: a87 }) : IteratorObject<{ a: number | undefined; b: string | undefined; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } >a : number[] >[1] : number[] @@ -1406,27 +1402,27 @@ const paddingI1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", pad >b : string[] >["a"] : string[] >"a" : "a" ->{ mode: "longest", padding: paddingH1 } : { mode: "longest"; padding: { a: number; } | { b: string; }; } +>{ mode: "longest", padding: a87 } : { mode: "longest"; padding: { a: number; } | { b: string; }; } >mode : "longest" >"longest" : "longest" >padding : { a: number; } | { b: string; } ->paddingH1 : { a: number; } | { b: string; } ->toArray : () => { a: number | undefined; b: string | undefined; }[] +>a87 : { a: number; } | { b: string; } +>toArray : () => ({ a: number | undefined; b: string | undefined; } & {})[] -const paddingJ1: { a: number; b: string; }[] = paddingI1; ->paddingJ1 : { a: number; b: string; }[] +const a89: { a: number; b: string; }[] = a88; +>a89 : { a: number; b: string; }[] >a : number >b : string ->paddingI1 : { a: number | undefined; b: string | undefined; }[] +>a88 : ({ a: number | undefined; b: string | undefined; } & {})[] -const paddingK1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); ->paddingK1 : { a: number | undefined; b: number; }[] ->Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray() : { a: number | undefined; b: number; }[] ->Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray : () => { a: number | undefined; b: number; }[] ->Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }) : IteratorObject<{ a: number | undefined; b: number; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a90 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); +>a90 : ({ a: number | undefined; b: number; } & {})[] +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray() : ({ a: number | undefined; b: number; } & {})[] +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray : () => ({ a: number | undefined; b: number; } & {})[] +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }) : IteratorObject<{ a: number | undefined; b: number; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: [1], b: [2] } : { a: number[]; b: number[]; } >a : number[] >[1] : number[] @@ -1443,77 +1439,77 @@ const paddingK1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", paddi >undefined : undefined >b : number >0 : 0 ->toArray : () => { a: number | undefined; b: number; }[] +>toArray : () => ({ a: number | undefined; b: number; } & {})[] -const paddingL1: { a: number; b: number; }[] = paddingK1; ->paddingL1 : { a: number; b: number; }[] +const a91: { a: number; b: number; }[] = a90; +>a91 : { a: number; b: number; }[] >a : number >b : number ->paddingK1 : { a: number | undefined; b: number; }[] +>a90 : ({ a: number | undefined; b: number; } & {})[] -declare const paddingM1: { [K in `a${string}`]: Iterable; }; ->paddingM1 : { [x: `a${string}`]: Iterable; } +declare const a92: { [K in `a${string}`]: Iterable; }; +>a92 : { [x: `a${string}`]: Iterable; } -const paddingN1 = Iterator.zipKeyed(paddingM1, { mode: "longest", padding: {} }).toArray(); ->paddingN1 : { [x: `a${string}`]: number | undefined; }[] ->Iterator.zipKeyed(paddingM1, { mode: "longest", padding: {} }).toArray() : { [x: `a${string}`]: number | undefined; }[] ->Iterator.zipKeyed(paddingM1, { mode: "longest", padding: {} }).toArray : () => { [x: `a${string}`]: number | undefined; }[] ->Iterator.zipKeyed(paddingM1, { mode: "longest", padding: {} }) : IteratorObject<{ [x: `a${string}`]: number | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a93 = Iterator.zipKeyed(a92, { mode: "longest", padding: {} }).toArray(); +>a93 : ({ [x: `a${string}`]: number | undefined; } & {})[] +>Iterator.zipKeyed(a92, { mode: "longest", padding: {} }).toArray() : ({ [x: `a${string}`]: number | undefined; } & {})[] +>Iterator.zipKeyed(a92, { mode: "longest", padding: {} }).toArray : () => ({ [x: `a${string}`]: number | undefined; } & {})[] +>Iterator.zipKeyed(a92, { mode: "longest", padding: {} }) : IteratorObject<{ [x: `a${string}`]: number | undefined; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->paddingM1 : { [x: `a${string}`]: Iterable; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a92 : { [x: `a${string}`]: Iterable; } >{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } >mode : "longest" >"longest" : "longest" >padding : {} >{} : {} ->toArray : () => { [x: `a${string}`]: number | undefined; }[] - -const paddingO1: { [K in `a${string}`]: number; }[] = paddingN1; ->paddingO1 : { [x: `a${string}`]: number; }[] ->paddingN1 : { [x: `a${string}`]: number | undefined; }[] - -declare const paddingP1: unique symbol; ->paddingP1 : unique symbol - -const paddingQ1: { [paddingP1]: number; }[] = Iterator.zipKeyed({ [paddingP1]: [1] }, { mode: "longest", padding: { [paddingP1]: 0 } }).toArray(); ->paddingQ1 : { [paddingP1]: number; }[] ->[paddingP1] : number ->paddingP1 : unique symbol ->Iterator.zipKeyed({ [paddingP1]: [1] }, { mode: "longest", padding: { [paddingP1]: 0 } }).toArray() : { [paddingP1]: number; }[] ->Iterator.zipKeyed({ [paddingP1]: [1] }, { mode: "longest", padding: { [paddingP1]: 0 } }).toArray : () => { [paddingP1]: number; }[] ->Iterator.zipKeyed({ [paddingP1]: [1] }, { mode: "longest", padding: { [paddingP1]: 0 } }) : IteratorObject<{ [paddingP1]: number; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->{ [paddingP1]: [1] } : { [paddingP1]: number[]; } ->[paddingP1] : number[] ->paddingP1 : unique symbol +>toArray : () => ({ [x: `a${string}`]: number | undefined; } & {})[] + +const a94: { [K in `a${string}`]: number; }[] = a93; +>a94 : { [x: `a${string}`]: number; }[] +>a93 : ({ [x: `a${string}`]: number | undefined; } & {})[] + +declare const a95: unique symbol; +>a95 : unique symbol + +const a96: { [a95]: number; }[] = Iterator.zipKeyed({ [a95]: [1] }, { mode: "longest", padding: { [a95]: 0 } }).toArray(); +>a96 : { [a95]: number; }[] +>[a95] : number +>a95 : unique symbol +>Iterator.zipKeyed({ [a95]: [1] }, { mode: "longest", padding: { [a95]: 0 } }).toArray() : ({ [a95]: number; } & {})[] +>Iterator.zipKeyed({ [a95]: [1] }, { mode: "longest", padding: { [a95]: 0 } }).toArray : () => ({ [a95]: number; } & {})[] +>Iterator.zipKeyed({ [a95]: [1] }, { mode: "longest", padding: { [a95]: 0 } }) : IteratorObject<{ [a95]: number; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ [a95]: [1] } : { [a95]: number[]; } +>[a95] : number[] +>a95 : unique symbol >[1] : number[] >1 : 1 ->{ mode: "longest", padding: { [paddingP1]: 0 } } : { mode: "longest"; padding: { [paddingP1]: number; }; } +>{ mode: "longest", padding: { [a95]: 0 } } : { mode: "longest"; padding: { [a95]: number; }; } >mode : "longest" >"longest" : "longest" ->padding : { [paddingP1]: number; } ->{ [paddingP1]: 0 } : { [paddingP1]: number; } ->[paddingP1] : number ->paddingP1 : unique symbol +>padding : { [a95]: number; } +>{ [a95]: 0 } : { [a95]: number; } +>[a95] : number +>a95 : unique symbol >0 : 0 ->toArray : () => { [paddingP1]: number; }[] +>toArray : () => ({ [a95]: number; } & {})[] -declare const paddingR1: Record & { a: number; }; ->paddingR1 : Record & { a: number; } +declare const a97: Record & { a: number; }; +>a97 : Record & { a: number; } >a : number -const paddingS1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: paddingR1 }).toArray(); ->paddingS1 : { a: number; b: number | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: paddingR1 }).toArray() : { a: number; b: number | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: paddingR1 }).toArray : () => { a: number; b: number | undefined; }[] ->Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: paddingR1 }) : IteratorObject<{ a: number; b: number | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a98 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: a97 }).toArray(); +>a98 : ({ a: number; b: number | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: a97 }).toArray() : ({ a: number; b: number | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: a97 }).toArray : () => ({ a: number; b: number | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: a97 }) : IteratorObject<{ a: number; b: number | undefined; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >{ a: [1], b: [2] } : { a: number[]; b: number[]; } >a : number[] >[1] : number[] @@ -1521,33 +1517,33 @@ const paddingS1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", paddi >b : number[] >[2] : number[] >2 : 2 ->{ mode: "longest", padding: paddingR1 } : { mode: "longest"; padding: Record & { a: number; }; } +>{ mode: "longest", padding: a97 } : { mode: "longest"; padding: Record & { a: number; }; } >mode : "longest" >"longest" : "longest" >padding : Record & { a: number; } ->paddingR1 : Record & { a: number; } ->toArray : () => { a: number; b: number | undefined; }[] +>a97 : Record & { a: number; } +>toArray : () => ({ a: number; b: number | undefined; } & {})[] -const paddingT1: { a: number; b: number | undefined; }[] = paddingS1; ->paddingT1 : { a: number; b: number | undefined; }[] +const a99: { a: number; b: number | undefined; }[] = a98; +>a99 : { a: number; b: number | undefined; }[] >a : number >b : number | undefined ->paddingS1 : { a: number; b: number | undefined; }[] +>a98 : ({ a: number; b: number | undefined; } & {})[] -const paddingU1: { a: number; b: number; }[] = paddingS1; ->paddingU1 : { a: number; b: number; }[] +const a100: { a: number; b: number; }[] = a98; +>a100 : { a: number; b: number; }[] >a : number >b : number ->paddingS1 : { a: number; b: number | undefined; }[] +>a98 : ({ a: number; b: number | undefined; } & {})[] -declare const paddingV1: [number] | [number, string]; ->paddingV1 : [number] | [number, string] +declare const a101: [number] | [number, string]; +>a101 : [number] | [number, string] -const paddingW1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingV1 }).toArray(); ->paddingW1 : [number, string | undefined][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingV1 }).toArray() : [number, string | undefined][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingV1 }).toArray : () => [number, string | undefined][] ->Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingV1 }) : IteratorObject<[number, string | undefined], undefined, unknown> +const a102 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a101 }).toArray(); +>a102 : [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: a101 }).toArray() : [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: a101 }).toArray : () => [number, string | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: a101 }) : IteratorObject<[number, string | undefined], undefined, unknown> >Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor >zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } @@ -1556,23 +1552,23 @@ const paddingW1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: padding >1 : 1 >["a"] : string[] >"a" : "a" ->{ mode: "longest", padding: paddingV1 } : { mode: "longest"; padding: [number] | [number, string]; } +>{ mode: "longest", padding: a101 } : { mode: "longest"; padding: [number] | [number, string]; } >mode : "longest" >"longest" : "longest" >padding : [number] | [number, string] ->paddingV1 : [number] | [number, string] +>a101 : [number] | [number, string] >toArray : () => [number, string | undefined][] -const paddingX1: [number, string | undefined][] = paddingW1; ->paddingX1 : [number, string | undefined][] ->paddingW1 : [number, string | undefined][] +const a103: [number, string | undefined][] = a102; +>a103 : [number, string | undefined][] +>a102 : [number, string | undefined][] -const paddingY1: [number, string][] = paddingW1; ->paddingY1 : [number, string][] ->paddingW1 : [number, string | undefined][] +const a104: [number, string][] = a102; +>a104 : [number, string][] +>a102 : [number, string | undefined][] -const paddingZ1: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); ->paddingZ1 : [number | undefined, number][] +const a105: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); +>a105 : [number | undefined, number][] >Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray() : [number | undefined, number][] >Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray : () => [number | undefined, number][] >Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }) : IteratorObject<[number | undefined, number], undefined, unknown> @@ -1593,184 +1589,179 @@ const paddingZ1: [number | undefined, number][] = Iterator.zip([[1], [2]], { mod >0 : 0 >toArray : () => [number | undefined, number][] -const paddingA2: { a: number | undefined; b: number; }[] = paddingK1; ->paddingA2 : { a: number | undefined; b: number; }[] +const a106: { a: number | undefined; b: number; }[] = a90; +>a106 : { a: number | undefined; b: number; }[] >a : number | undefined >b : number ->paddingK1 : { a: number | undefined; b: number; }[] +>a90 : ({ a: number | undefined; b: number; } & {})[] -// Own properties +class C1 { +>C1 : C1 -class InputsWithPrototypeMembers { ->InputsWithPrototypeMembers : InputsWithPrototypeMembers - - values = [1, 2]; ->values : number[] + a = [1, 2]; +>a : number[] >[1, 2] : number[] >1 : 1 >2 : 2 - get label() { ->label : string + get b() { +>b : string return "inputs"; >"inputs" : "inputs" } - describe() { ->describe : () => string + f() { +>f : () => string - return this.label; ->this.label : string + return this.b; +>this.b : string >this : this ->label : string +>b : string } } -const instance = new InputsWithPrototypeMembers(); ->instance : InputsWithPrototypeMembers ->new InputsWithPrototypeMembers() : InputsWithPrototypeMembers ->InputsWithPrototypeMembers : typeof InputsWithPrototypeMembers +const a107 = new C1(); +>a107 : C1 +>new C1() : C1 +>C1 : typeof C1 -const inherited = Iterator.zipKeyed(instance).toArray(); ->inherited : Record[] ->Iterator.zipKeyed(instance).toArray() : Record[] ->Iterator.zipKeyed(instance).toArray : () => Record[] ->Iterator.zipKeyed(instance) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a108 = Iterator.zipKeyed(a107).toArray(); +>a108 : Record[] +>Iterator.zipKeyed(a107).toArray() : Record[] +>Iterator.zipKeyed(a107).toArray : () => Record[] +>Iterator.zipKeyed(a107) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->instance : InputsWithPrototypeMembers +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a107 : C1 >toArray : () => Record[] -const inheritedStrict = Iterator.zipKeyed(instance, { mode: "strict" }).toArray(); ->inheritedStrict : Record[] ->Iterator.zipKeyed(instance, { mode: "strict" }).toArray() : Record[] ->Iterator.zipKeyed(instance, { mode: "strict" }).toArray : () => Record[] ->Iterator.zipKeyed(instance, { mode: "strict" }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a109 = Iterator.zipKeyed(a107, { mode: "strict" }).toArray(); +>a109 : Record[] +>Iterator.zipKeyed(a107, { mode: "strict" }).toArray() : Record[] +>Iterator.zipKeyed(a107, { mode: "strict" }).toArray : () => Record[] +>Iterator.zipKeyed(a107, { mode: "strict" }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->instance : InputsWithPrototypeMembers +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a107 : C1 >{ mode: "strict" } : { mode: "strict"; } >mode : "strict" >"strict" : "strict" >toArray : () => Record[] -const inheritedLongest = Iterator.zipKeyed(instance, { mode: "longest" }).toArray(); ->inheritedLongest : Record[] ->Iterator.zipKeyed(instance, { mode: "longest" }).toArray() : Record[] ->Iterator.zipKeyed(instance, { mode: "longest" }).toArray : () => Record[] ->Iterator.zipKeyed(instance, { mode: "longest" }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a110 = Iterator.zipKeyed(a107, { mode: "longest" }).toArray(); +>a110 : Record[] +>Iterator.zipKeyed(a107, { mode: "longest" }).toArray() : Record[] +>Iterator.zipKeyed(a107, { mode: "longest" }).toArray : () => Record[] +>Iterator.zipKeyed(a107, { mode: "longest" }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->instance : InputsWithPrototypeMembers +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a107 : C1 >{ mode: "longest" } : { mode: "longest"; } >mode : "longest" >"longest" : "longest" >toArray : () => Record[] -const inheritedPadded = Iterator.zipKeyed(instance, { mode: "longest", padding: { values: 0 } }).toArray(); ->inheritedPadded : Record[] ->Iterator.zipKeyed(instance, { mode: "longest", padding: { values: 0 } }).toArray() : Record[] ->Iterator.zipKeyed(instance, { mode: "longest", padding: { values: 0 } }).toArray : () => Record[] ->Iterator.zipKeyed(instance, { mode: "longest", padding: { values: 0 } }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a111 = Iterator.zipKeyed(a107, { mode: "longest", padding: { a: 0 } }).toArray(); +>a111 : Record[] +>Iterator.zipKeyed(a107, { mode: "longest", padding: { a: 0 } }).toArray() : Record[] +>Iterator.zipKeyed(a107, { mode: "longest", padding: { a: 0 } }).toArray : () => Record[] +>Iterator.zipKeyed(a107, { mode: "longest", padding: { a: 0 } }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->instance : InputsWithPrototypeMembers ->{ mode: "longest", padding: { values: 0 } } : { mode: "longest"; padding: { values: number; }; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a107 : C1 +>{ mode: "longest", padding: { a: 0 } } : { mode: "longest"; padding: { a: number; }; } >mode : "longest" >"longest" : "longest" ->padding : { values: number; } ->{ values: 0 } : { values: number; } ->values : number +>padding : { a: number; } +>{ a: 0 } : { a: number; } +>a : number >0 : 0 >toArray : () => Record[] -const hiddenInputs = { values: [1, 2], label: "inputs" }; ->hiddenInputs : { values: number[]; label: string; } ->{ values: [1, 2], label: "inputs" } : { values: number[]; label: string; } ->values : number[] +const a112 = { a: [1, 2], b: "inputs" }; +>a112 : { a: number[]; b: string; } +>{ a: [1, 2], b: "inputs" } : { a: number[]; b: string; } +>a : number[] >[1, 2] : number[] >1 : 1 >2 : 2 ->label : string +>b : string >"inputs" : "inputs" -Object.defineProperty(hiddenInputs, "label", { enumerable: false }); ->Object.defineProperty(hiddenInputs, "label", { enumerable: false }) : { values: number[]; label: string; } +Object.defineProperty(a112, "b", { enumerable: false }); +>Object.defineProperty(a112, "b", { enumerable: false }) : { a: number[]; b: string; } >Object.defineProperty : (o: T, p: PropertyKey, attributes: PropertyDescriptor & ThisType) => T >Object : ObjectConstructor >defineProperty : (o: T, p: PropertyKey, attributes: PropertyDescriptor & ThisType) => T ->hiddenInputs : { values: number[]; label: string; } ->"label" : "label" +>a112 : { a: number[]; b: string; } +>"b" : "b" >{ enumerable: false } : { enumerable: false; } >enumerable : false >false : false -const nonEnumerable = Iterator.zipKeyed(hiddenInputs).toArray(); ->nonEnumerable : Record[] ->Iterator.zipKeyed(hiddenInputs).toArray() : Record[] ->Iterator.zipKeyed(hiddenInputs).toArray : () => Record[] ->Iterator.zipKeyed(hiddenInputs) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a113 = Iterator.zipKeyed(a112).toArray(); +>a113 : Record[] +>Iterator.zipKeyed(a112).toArray() : Record[] +>Iterator.zipKeyed(a112).toArray : () => Record[] +>Iterator.zipKeyed(a112) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->hiddenInputs : { values: number[]; label: string; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a112 : { a: number[]; b: string; } >toArray : () => Record[] -const nonEnumerablePadded = Iterator.zipKeyed(hiddenInputs, { mode: "longest", padding: { values: 0 } }).toArray(); ->nonEnumerablePadded : Record[] ->Iterator.zipKeyed(hiddenInputs, { mode: "longest", padding: { values: 0 } }).toArray() : Record[] ->Iterator.zipKeyed(hiddenInputs, { mode: "longest", padding: { values: 0 } }).toArray : () => Record[] ->Iterator.zipKeyed(hiddenInputs, { mode: "longest", padding: { values: 0 } }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a114 = Iterator.zipKeyed(a112, { mode: "longest", padding: { a: 0 } }).toArray(); +>a114 : Record[] +>Iterator.zipKeyed(a112, { mode: "longest", padding: { a: 0 } }).toArray() : Record[] +>Iterator.zipKeyed(a112, { mode: "longest", padding: { a: 0 } }).toArray : () => Record[] +>Iterator.zipKeyed(a112, { mode: "longest", padding: { a: 0 } }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->hiddenInputs : { values: number[]; label: string; } ->{ mode: "longest", padding: { values: 0 } } : { mode: "longest"; padding: { values: number; }; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a112 : { a: number[]; b: string; } +>{ mode: "longest", padding: { a: 0 } } : { mode: "longest"; padding: { a: number; }; } >mode : "longest" >"longest" : "longest" ->padding : { values: number; } ->{ values: 0 } : { values: number; } ->values : number +>padding : { a: number; } +>{ a: 0 } : { a: number; } +>a : number >0 : 0 >toArray : () => Record[] -// The same static shape can have an enumerable non-iterator property instead. -// Such inputs are accepted by the fallback and checked at runtime. -const enumerableInputs = { values: [1, 2], label: "inputs" }; ->enumerableInputs : { values: number[]; label: string; } ->{ values: [1, 2], label: "inputs" } : { values: number[]; label: string; } ->values : number[] +const a115 = { a: [1, 2], b: "inputs" }; +>a115 : { a: number[]; b: string; } +>{ a: [1, 2], b: "inputs" } : { a: number[]; b: string; } +>a : number[] >[1, 2] : number[] >1 : 1 >2 : 2 ->label : string +>b : string >"inputs" : "inputs" -const enumerable = Iterator.zipKeyed(enumerableInputs).toArray(); ->enumerable : Record[] ->Iterator.zipKeyed(enumerableInputs).toArray() : Record[] ->Iterator.zipKeyed(enumerableInputs).toArray : () => Record[] ->Iterator.zipKeyed(enumerableInputs) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a116 = Iterator.zipKeyed(a115).toArray(); +>a116 : Record[] +>Iterator.zipKeyed(a115).toArray() : Record[] +>Iterator.zipKeyed(a115).toArray : () => Record[] +>Iterator.zipKeyed(a115) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->enumerableInputs : { values: number[]; label: string; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a115 : { a: number[]; b: string; } >toArray : () => Record[] -// The array's length and methods are not enumerable own properties. -const arrayInputs = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); ->arrayInputs : Record[] +const a117 = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); +>a117 : Record[] >Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray() : Record[] >Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray : () => Record[] >Iterator.zipKeyed([[1, 2], ["a", "b"]]) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >[[1, 2], ["a", "b"]] : (string[] | number[])[] >[1, 2] : number[] >1 : 1 @@ -1780,160 +1771,269 @@ const arrayInputs = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); >"b" : "b" >toArray : () => Record[] -// The fallback must not claim that ignored properties exist on yielded objects. -const inheritedLabel: string = inherited[0].label; ->inheritedLabel : string ->inherited[0].label : unknown ->inherited[0] : Record ->inherited : Record[] +const a118: string = a108[0].b; +>a118 : string +>a108[0].b : unknown +>a108[0] : Record +>a108 : Record[] >0 : 0 ->label : unknown +>b : unknown -const nonEnumerableLabel: string = nonEnumerable[0].label; ->nonEnumerableLabel : string ->nonEnumerable[0].label : unknown ->nonEnumerable[0] : Record ->nonEnumerable : Record[] +const a119: string = a113[0].b; +>a119 : string +>a113[0].b : unknown +>a113[0] : Record +>a113 : Record[] >0 : 0 ->label : unknown - -// Precise record inference still handles symbol keys and padding. -declare const ownKey: unique symbol; ->ownKey : unique symbol - -const precise: { values: number; [ownKey]: string; }[] = Iterator.zipKeyed({ values: [1], [ownKey]: ["a"] }).toArray(); ->precise : { values: number; [ownKey]: string; }[] ->values : number ->[ownKey] : string ->ownKey : unique symbol ->Iterator.zipKeyed({ values: [1], [ownKey]: ["a"] }).toArray() : { values: number; [ownKey]: string; }[] ->Iterator.zipKeyed({ values: [1], [ownKey]: ["a"] }).toArray : () => { values: number; [ownKey]: string; }[] ->Iterator.zipKeyed({ values: [1], [ownKey]: ["a"] }) : IteratorObject<{ values: number; [ownKey]: string; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->{ values: [1], [ownKey]: ["a"] } : { values: number[]; [ownKey]: string[]; } ->values : number[] +>b : unknown + +declare const a120: unique symbol; +>a120 : unique symbol + +const a121: { a: number; [a120]: string; }[] = Iterator.zipKeyed({ a: [1], [a120]: ["a"] }).toArray(); +>a121 : { a: number; [a120]: string; }[] +>a : number +>[a120] : string +>a120 : unique symbol +>Iterator.zipKeyed({ a: [1], [a120]: ["a"] }).toArray() : ({ a: number; [a120]: string; } & {})[] +>Iterator.zipKeyed({ a: [1], [a120]: ["a"] }).toArray : () => ({ a: number; [a120]: string; } & {})[] +>Iterator.zipKeyed({ a: [1], [a120]: ["a"] }) : IteratorObject<{ a: number; [a120]: string; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1], [a120]: ["a"] } : { a: number[]; [a120]: string[]; } +>a : number[] >[1] : number[] >1 : 1 ->[ownKey] : string[] ->ownKey : unique symbol +>[a120] : string[] +>a120 : unique symbol >["a"] : string[] >"a" : "a" ->toArray : () => { values: number; [ownKey]: string; }[] - -const preciseLongest: { values: number | undefined; }[] = Iterator.zipKeyed({ values: [1] }, { mode: "longest" }).toArray(); ->preciseLongest : { values: number | undefined; }[] ->values : number | undefined ->Iterator.zipKeyed({ values: [1] }, { mode: "longest" }).toArray() : { values: number | undefined; }[] ->Iterator.zipKeyed({ values: [1] }, { mode: "longest" }).toArray : () => { values: number | undefined; }[] ->Iterator.zipKeyed({ values: [1] }, { mode: "longest" }) : IteratorObject<{ values: number | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->{ values: [1] } : { values: number[]; } ->values : number[] +>toArray : () => ({ a: number; [a120]: string; } & {})[] + +const a122: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1] }, { mode: "longest" }).toArray(); +>a122 : { a: number | undefined; }[] +>a : number | undefined +>Iterator.zipKeyed({ a: [1] }, { mode: "longest" }).toArray() : ({ a: number | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1] }, { mode: "longest" }).toArray : () => ({ a: number | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1] }, { mode: "longest" }) : IteratorObject<{ a: number | undefined; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1] } : { a: number[]; } +>a : number[] >[1] : number[] >1 : 1 >{ mode: "longest" } : { mode: "longest"; } >mode : "longest" >"longest" : "longest" ->toArray : () => { values: number | undefined; }[] - -const precisePadded: { values: number; }[] = Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: 0 } }).toArray(); ->precisePadded : { values: number; }[] ->values : number ->Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: 0 } }).toArray() : { values: number; }[] ->Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: 0 } }).toArray : () => { values: number; }[] ->Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: 0 } }) : IteratorObject<{ values: number; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->{ values: [1] } : { values: number[]; } ->values : number[] +>toArray : () => ({ a: number | undefined; } & {})[] + +const a123: { a: number; }[] = Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray(); +>a123 : { a: number; }[] +>a : number +>Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray() : ({ a: number; } & {})[] +>Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray : () => ({ a: number; } & {})[] +>Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: 0 } }) : IteratorObject<{ a: number; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1] } : { a: number[]; } +>a : number[] >[1] : number[] >1 : 1 ->{ mode: "longest", padding: { values: 0 } } : { mode: "longest"; padding: { values: number; }; } +>{ mode: "longest", padding: { a: 0 } } : { mode: "longest"; padding: { a: number; }; } >mode : "longest" >"longest" : "longest" ->padding : { values: number; } ->{ values: 0 } : { values: number; } ->values : number +>padding : { a: number; } +>{ a: 0 } : { a: number; } +>a : number >0 : 0 ->toArray : () => { values: number; }[] +>toArray : () => ({ a: number; } & {})[] + +declare const a124: object; +>a124 : object -const emptyOwnProperties: never[] = Iterator.zipKeyed({}).toArray(); ->emptyOwnProperties : never[] ->Iterator.zipKeyed({}).toArray() : never[] ->Iterator.zipKeyed({}).toArray : () => never[] ->Iterator.zipKeyed({}) : IteratorObject ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a125 = Iterator.zipKeyed(a124).toArray(); +>a125 : Record[] +>Iterator.zipKeyed(a124).toArray() : Record[] +>Iterator.zipKeyed(a124).toArray : () => Record[] +>Iterator.zipKeyed(a124) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->{} : {} ->toArray : () => never[] +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a124 : object +>toArray : () => Record[] + +const a126 = Iterator.zipKeyed(a124, { mode: "strict" }).toArray(); +>a126 : Record[] +>Iterator.zipKeyed(a124, { mode: "strict" }).toArray() : Record[] +>Iterator.zipKeyed(a124, { mode: "strict" }).toArray : () => Record[] +>Iterator.zipKeyed(a124, { mode: "strict" }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a124 : object +>{ mode: "strict" } : { mode: "strict"; } +>mode : "strict" +>"strict" : "strict" +>toArray : () => Record[] + +const a127 = Iterator.zipKeyed(a124, { mode: "longest" }).toArray(); +>a127 : Record[] +>Iterator.zipKeyed(a124, { mode: "longest" }).toArray() : Record[] +>Iterator.zipKeyed(a124, { mode: "longest" }).toArray : () => Record[] +>Iterator.zipKeyed(a124, { mode: "longest" }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a124 : object +>{ mode: "longest" } : { mode: "longest"; } +>mode : "longest" +>"longest" : "longest" +>toArray : () => Record[] + +const a128 = Iterator.zipKeyed(a124, { mode: "longest", padding: { a: 0 } }).toArray(); +>a128 : Record[] +>Iterator.zipKeyed(a124, { mode: "longest", padding: { a: 0 } }).toArray() : Record[] +>Iterator.zipKeyed(a124, { mode: "longest", padding: { a: 0 } }).toArray : () => Record[] +>Iterator.zipKeyed(a124, { mode: "longest", padding: { a: 0 } }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a124 : object +>{ mode: "longest", padding: { a: 0 } } : { mode: "longest"; padding: { a: number; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: number; } +>{ a: 0 } : { a: number; } +>a : number +>0 : 0 +>toArray : () => Record[] + +const a129: unknown = a125[0].a; +>a129 : unknown +>a125[0].a : unknown +>a125[0] : Record +>a125 : Record[] +>0 : 0 +>a : unknown + +const a130: unknown = a126[0].a; +>a130 : unknown +>a126[0].a : unknown +>a126[0] : Record +>a126 : Record[] +>0 : 0 +>a : unknown + +const a131: unknown = a127[0].a; +>a131 : unknown +>a127[0].a : unknown +>a127[0] : Record +>a127 : Record[] +>0 : 0 +>a : unknown + +const a132: unknown = a128[0].a; +>a132 : unknown +>a128[0].a : unknown +>a128[0] : Record +>a128 : Record[] +>0 : 0 +>a : unknown + +const a133: never[] = a125; +>a133 : never[] +>a125 : Record[] + +declare const a134: {}; +>a134 : {} + +const a135 = Iterator.zipKeyed(a134).toArray(); +>a135 : Record[] +>Iterator.zipKeyed(a134).toArray() : Record[] +>Iterator.zipKeyed(a134).toArray : () => Record[] +>Iterator.zipKeyed(a134) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a134 : {} +>toArray : () => Record[] + +const a136: unknown = a135[0].a; +>a136 : unknown +>a135[0].a : unknown +>a135[0] : Record +>a135 : Record[] +>0 : 0 +>a : unknown + +const a137: never[] = a135; +>a137 : never[] +>a135 : Record[] Iterator.zipKeyed(0); ->Iterator.zipKeyed(0) : IteratorObject ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed(0) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >0 : 0 Iterator.zipKeyed(null); ->Iterator.zipKeyed(null) : IteratorObject ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed(null) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } -Iterator.zipKeyed(instance, { mode: "invalid" }); ->Iterator.zipKeyed(instance, { mode: "invalid" }) : IteratorObject<{ values: number; label: never; describe: never; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +Iterator.zipKeyed(a107, { mode: "invalid" }); +>Iterator.zipKeyed(a107, { mode: "invalid" }) : IteratorObject<{ a: number; b: never; f: never; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->instance : InputsWithPrototypeMembers +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a107 : C1 >{ mode: "invalid" } : { mode: "invalid"; } >mode : "invalid" >"invalid" : "invalid" -Iterator.zipKeyed(instance, { mode: "shortest", padding: {} }); ->Iterator.zipKeyed(instance, { mode: "shortest", padding: {} }) : IteratorObject<{ values: number; label: never; describe: never; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +Iterator.zipKeyed(a107, { mode: "shortest", padding: {} }); +>Iterator.zipKeyed(a107, { mode: "shortest", padding: {} }) : IteratorObject<{ a: number; b: never; f: never; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->instance : InputsWithPrototypeMembers +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a107 : C1 >{ mode: "shortest", padding: {} } : { mode: "shortest"; padding: {}; } >mode : "shortest" >"shortest" : "shortest" >padding : {} >{} : {} -Iterator.zipKeyed(instance, { mode: "longest", padding: 0 }); ->Iterator.zipKeyed(instance, { mode: "longest", padding: 0 }) : IteratorObject<{ values: number; label: never; describe: never; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +Iterator.zipKeyed(a107, { mode: "longest", padding: 0 }); +>Iterator.zipKeyed(a107, { mode: "longest", padding: 0 }) : IteratorObject<{ a: number; b: never; f: never; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->instance : InputsWithPrototypeMembers +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a107 : C1 >{ mode: "longest", padding: 0 } : { mode: "longest"; padding: number; } >mode : "longest" >"longest" : "longest" >padding : number >0 : 0 -Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: "invalid" } }); ->Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: "invalid" } }) : IteratorObject<{ values: number; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: "invalid" } }); +>Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: "invalid" } }) : IteratorObject<{ a: number; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding_1 ? TPadding_1[K] : never) | (K extends keyof { [K_1 in keyof TPadding_1 as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? never : { [K in keyof T as undefined extends T[K] ? never : K]: T[K]; } & { [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: T[K]; } extends infer T_1 ? { -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : TExtra); } : never, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->{ values: [1] } : { values: number[]; } ->values : number[] +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a: [1] } : { a: number[]; } +>a : number[] >[1] : number[] >1 : 1 ->{ mode: "longest", padding: { values: "invalid" } } : { mode: "longest"; padding: { values: string; }; } +>{ mode: "longest", padding: { a: "invalid" } } : { mode: "longest"; padding: { a: string; }; } >mode : "longest" >"longest" : "longest" ->padding : { values: string; } ->{ values: "invalid" } : { values: string; } ->values : string +>padding : { a: string; } +>{ a: "invalid" } : { a: string; } +>a : string >"invalid" : "invalid" diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=false).js b/tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=false).js new file mode 100644 index 0000000000000..257ec6471ed72 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=false).js @@ -0,0 +1,108 @@ +//// [tests/cases/compiler/iteratorZipDeclarations.ts] //// + +//// [iteratorZipDeclarations.ts] +export function f1>>(a: T) { + return Iterator.zipKeyed(a); +} + +export function f2>>(a: T) { + return Iterator.zipKeyed(a, { mode: "longest" }); +} + +export function f3>>(a: T) { + return Iterator.zipKeyed(a, { mode: "longest", padding: {} }); +} + +export function f4(a: T) { + return Iterator.zipKeyed(a); +} + +export function f5(a: Iterable, b: T) { + return Iterator.zipKeyed({ a }, { mode: "longest", padding: { a: b } }); +} + +export function f6 | Iterator)[]>(a: T) { + return Iterator.zip(a); +} + +export function f7(a: Iterable, b: U) { + return Iterator.zipKeyed({ a }, { mode: "longest", padding: b }); +} + +export const a = f1({ a: [1], b: ["a"] }).toArray(); +export const b = f2({ a: [1], b: ["a"] }).toArray(); +export const c = f3({ a: [1], b: ["a"] }).toArray(); +export const d = f4({ a: [1], b: ["a"] }).toArray(); +export const e = f5([1], 0).toArray(); +export const f = f6([[1], ["a"]] as const).toArray(); +export const g = f7([1], { a: 0 }).toArray(); + + +//// [iteratorZipDeclarations.js] +export function f1(a) { + return Iterator.zipKeyed(a); +} +export function f2(a) { + return Iterator.zipKeyed(a, { mode: "longest" }); +} +export function f3(a) { + return Iterator.zipKeyed(a, { mode: "longest", padding: {} }); +} +export function f4(a) { + return Iterator.zipKeyed(a); +} +export function f5(a, b) { + return Iterator.zipKeyed({ a }, { mode: "longest", padding: { a: b } }); +} +export function f6(a) { + return Iterator.zip(a); +} +export function f7(a, b) { + return Iterator.zipKeyed({ a }, { mode: "longest", padding: b }); +} +export const a = f1({ a: [1], b: ["a"] }).toArray(); +export const b = f2({ a: [1], b: ["a"] }).toArray(); +export const c = f3({ a: [1], b: ["a"] }).toArray(); +export const d = f4({ a: [1], b: ["a"] }).toArray(); +export const e = f5([1], 0).toArray(); +export const f = f6([[1], ["a"]]).toArray(); +export const g = f7([1], { a: 0 }).toArray(); + + +//// [iteratorZipDeclarations.d.ts] +export declare function f1>>(a: T): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; +export declare function f2>>(a: T): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; +export declare function f3>>(a: T): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; +export declare function f4(a: T): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; +export declare function f5(a: Iterable, b: T): IteratorObject<{ + a: T; +} & {}, undefined, unknown>; +export declare function f6 | Iterator)[]>(a: T): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; +export declare function f7(a: Iterable, b: U): IteratorObject<{ + a: T | ("a" extends infer T_1 ? T_1 extends "a" ? T_1 extends keyof U ? U[T_1] : never : never : never) | ("a" extends infer T_2 ? T_2 extends "a" ? T_2 extends keyof { [K in keyof U as {} extends Pick ? never : K]: unknown; } ? never : undefined : never : never); +} & {}, undefined, unknown>; +export declare const a: ({ + a: number; + b: string; +} & {})[]; +export declare const b: ({ + a: number | undefined; + b: string | undefined; +} & {})[]; +export declare const c: ({ + a: number | undefined; + b: string | undefined; +} & {})[]; +export declare const d: ({ + a: number; + b: string; +} & {})[]; +export declare const e: ({ + a: number; +} & {})[]; +export declare const f: [1, "a"][]; +export declare const g: ({ + a: number; +} & {})[]; diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=false).symbols b/tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=false).symbols new file mode 100644 index 0000000000000..0908a94f18793 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=false).symbols @@ -0,0 +1,173 @@ +//// [tests/cases/compiler/iteratorZipDeclarations.ts] //// + +=== iteratorZipDeclarations.ts === +export function f1>>(a: T) { +>f1 : Symbol(f1, Decl(iteratorZipDeclarations.ts, 0, 0)) +>T : Symbol(T, Decl(iteratorZipDeclarations.ts, 0, 19)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 0, 64)) +>T : Symbol(T, Decl(iteratorZipDeclarations.ts, 0, 19)) + + return Iterator.zipKeyed(a); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 0, 64)) +} + +export function f2>>(a: T) { +>f2 : Symbol(f2, Decl(iteratorZipDeclarations.ts, 2, 1)) +>T : Symbol(T, Decl(iteratorZipDeclarations.ts, 4, 19)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 4, 64)) +>T : Symbol(T, Decl(iteratorZipDeclarations.ts, 4, 19)) + + return Iterator.zipKeyed(a, { mode: "longest" }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 4, 64)) +>mode : Symbol(mode, Decl(iteratorZipDeclarations.ts, 5, 33)) +} + +export function f3>>(a: T) { +>f3 : Symbol(f3, Decl(iteratorZipDeclarations.ts, 6, 1)) +>T : Symbol(T, Decl(iteratorZipDeclarations.ts, 8, 19)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 8, 64)) +>T : Symbol(T, Decl(iteratorZipDeclarations.ts, 8, 19)) + + return Iterator.zipKeyed(a, { mode: "longest", padding: {} }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 8, 64)) +>mode : Symbol(mode, Decl(iteratorZipDeclarations.ts, 9, 33)) +>padding : Symbol(padding, Decl(iteratorZipDeclarations.ts, 9, 50)) +} + +export function f4(a: T) { +>f4 : Symbol(f4, Decl(iteratorZipDeclarations.ts, 10, 1)) +>T : Symbol(T, Decl(iteratorZipDeclarations.ts, 12, 19)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 12, 37)) +>T : Symbol(T, Decl(iteratorZipDeclarations.ts, 12, 19)) + + return Iterator.zipKeyed(a); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 12, 37)) +} + +export function f5(a: Iterable, b: T) { +>f5 : Symbol(f5, Decl(iteratorZipDeclarations.ts, 14, 1)) +>T : Symbol(T, Decl(iteratorZipDeclarations.ts, 16, 19)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 16, 22)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>T : Symbol(T, Decl(iteratorZipDeclarations.ts, 16, 19)) +>b : Symbol(b, Decl(iteratorZipDeclarations.ts, 16, 37)) +>T : Symbol(T, Decl(iteratorZipDeclarations.ts, 16, 19)) + + return Iterator.zipKeyed({ a }, { mode: "longest", padding: { a: b } }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 17, 30)) +>mode : Symbol(mode, Decl(iteratorZipDeclarations.ts, 17, 37)) +>padding : Symbol(padding, Decl(iteratorZipDeclarations.ts, 17, 54)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 17, 65)) +>b : Symbol(b, Decl(iteratorZipDeclarations.ts, 16, 37)) +} + +export function f6 | Iterator)[]>(a: T) { +>f6 : Symbol(f6, Decl(iteratorZipDeclarations.ts, 18, 1)) +>T : Symbol(T, Decl(iteratorZipDeclarations.ts, 20, 19)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 20, 81)) +>T : Symbol(T, Decl(iteratorZipDeclarations.ts, 20, 19)) + + return Iterator.zip(a); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 20, 81)) +} + +export function f7(a: Iterable, b: U) { +>f7 : Symbol(f7, Decl(iteratorZipDeclarations.ts, 22, 1)) +>T : Symbol(T, Decl(iteratorZipDeclarations.ts, 24, 19)) +>U : Symbol(U, Decl(iteratorZipDeclarations.ts, 24, 21)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 24, 33)) +>T : Symbol(T, Decl(iteratorZipDeclarations.ts, 24, 19)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 24, 44)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>T : Symbol(T, Decl(iteratorZipDeclarations.ts, 24, 19)) +>b : Symbol(b, Decl(iteratorZipDeclarations.ts, 24, 59)) +>U : Symbol(U, Decl(iteratorZipDeclarations.ts, 24, 21)) + + return Iterator.zipKeyed({ a }, { mode: "longest", padding: b }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 25, 30)) +>mode : Symbol(mode, Decl(iteratorZipDeclarations.ts, 25, 37)) +>padding : Symbol(padding, Decl(iteratorZipDeclarations.ts, 25, 54)) +>b : Symbol(b, Decl(iteratorZipDeclarations.ts, 24, 59)) +} + +export const a = f1({ a: [1], b: ["a"] }).toArray(); +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 28, 12)) +>f1({ a: [1], b: ["a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>f1 : Symbol(f1, Decl(iteratorZipDeclarations.ts, 0, 0)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 28, 21)) +>b : Symbol(b, Decl(iteratorZipDeclarations.ts, 28, 29)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +export const b = f2({ a: [1], b: ["a"] }).toArray(); +>b : Symbol(b, Decl(iteratorZipDeclarations.ts, 29, 12)) +>f2({ a: [1], b: ["a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>f2 : Symbol(f2, Decl(iteratorZipDeclarations.ts, 2, 1)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 29, 21)) +>b : Symbol(b, Decl(iteratorZipDeclarations.ts, 29, 29)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +export const c = f3({ a: [1], b: ["a"] }).toArray(); +>c : Symbol(c, Decl(iteratorZipDeclarations.ts, 30, 12)) +>f3({ a: [1], b: ["a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>f3 : Symbol(f3, Decl(iteratorZipDeclarations.ts, 6, 1)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 30, 21)) +>b : Symbol(b, Decl(iteratorZipDeclarations.ts, 30, 29)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +export const d = f4({ a: [1], b: ["a"] }).toArray(); +>d : Symbol(d, Decl(iteratorZipDeclarations.ts, 31, 12)) +>f4({ a: [1], b: ["a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>f4 : Symbol(f4, Decl(iteratorZipDeclarations.ts, 10, 1)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 31, 21)) +>b : Symbol(b, Decl(iteratorZipDeclarations.ts, 31, 29)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +export const e = f5([1], 0).toArray(); +>e : Symbol(e, Decl(iteratorZipDeclarations.ts, 32, 12)) +>f5([1], 0).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>f5 : Symbol(f5, Decl(iteratorZipDeclarations.ts, 14, 1)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +export const f = f6([[1], ["a"]] as const).toArray(); +>f : Symbol(f, Decl(iteratorZipDeclarations.ts, 33, 12)) +>f6([[1], ["a"]] as const).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>f6 : Symbol(f6, Decl(iteratorZipDeclarations.ts, 18, 1)) +>const : Symbol(const) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +export const g = f7([1], { a: 0 }).toArray(); +>g : Symbol(g, Decl(iteratorZipDeclarations.ts, 34, 12)) +>f7([1], { a: 0 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>f7 : Symbol(f7, Decl(iteratorZipDeclarations.ts, 22, 1)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 34, 26)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=false).types b/tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=false).types new file mode 100644 index 0000000000000..3d6bd6945b07c --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=false).types @@ -0,0 +1,210 @@ +//// [tests/cases/compiler/iteratorZipDeclarations.ts] //// + +=== iteratorZipDeclarations.ts === +export function f1>>(a: T) { +>f1 : >>(a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown> +>a : T + + return Iterator.zipKeyed(a); +>Iterator.zipKeyed(a) : IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a : T +} + +export function f2>>(a: T) { +>f2 : >>(a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown> +>a : T + + return Iterator.zipKeyed(a, { mode: "longest" }); +>Iterator.zipKeyed(a, { mode: "longest" }) : IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a : T +>{ mode: "longest" } : { mode: "longest"; } +>mode : "longest" +>"longest" : "longest" +} + +export function f3>>(a: T) { +>f3 : >>(a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown> +>a : T + + return Iterator.zipKeyed(a, { mode: "longest", padding: {} }); +>Iterator.zipKeyed(a, { mode: "longest", padding: {} }) : IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a : T +>{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } +>mode : "longest" +>"longest" : "longest" +>padding : {} +>{} : {} +} + +export function f4(a: T) { +>f4 : (a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown> +>a : T + + return Iterator.zipKeyed(a); +>Iterator.zipKeyed(a) : IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a : T +} + +export function f5(a: Iterable, b: T) { +>f5 : (a: Iterable, b: T) => IteratorObject<{ a: T; } & {}, undefined, unknown> +>a : Iterable +>b : T + + return Iterator.zipKeyed({ a }, { mode: "longest", padding: { a: b } }); +>Iterator.zipKeyed({ a }, { mode: "longest", padding: { a: b } }) : IteratorObject<{ a: T; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a } : { a: Iterable; } +>a : Iterable +>{ mode: "longest", padding: { a: b } } : { mode: "longest"; padding: { a: T; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: T; } +>{ a: b } : { a: T; } +>a : T +>b : T +} + +export function f6 | Iterator)[]>(a: T) { +>f6 : | Iterator)[]>(a: T) => IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown> +>a : T + + return Iterator.zip(a); +>Iterator.zip(a) : IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T_1, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T_1, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T_1, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T_1 extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T_1 extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T_1, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T_1, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T_1, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T_1 extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T_1 extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>a : T +} + +export function f7(a: Iterable, b: U) { +>f7 : (a: Iterable, b: U) => IteratorObject<{ a: T | ("a" extends infer T_1 ? T_1 extends "a" ? T_1 extends keyof U ? U[T_1] : never : never : never) | ("a" extends infer T_2 ? T_2 extends "a" ? T_2 extends keyof { [K in keyof U as {} extends Pick ? never : K]: unknown; } ? never : undefined : never : never); } & {}, undefined, unknown> +>a : T | undefined +>a : Iterable +>b : U + + return Iterator.zipKeyed({ a }, { mode: "longest", padding: b }); +>Iterator.zipKeyed({ a }, { mode: "longest", padding: b }) : IteratorObject<{ a: T | ("a" extends infer T_1 ? T_1 extends "a" ? T_1 extends keyof U ? U[T_1] : never : never : never) | ("a" extends infer T_2 ? T_2 extends "a" ? T_2 extends keyof { [K in keyof U as {} extends Pick ? never : K]: unknown; } ? never : undefined : never : never); } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U_1 : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U_1 : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a } : { a: Iterable; } +>a : Iterable +>{ mode: "longest", padding: b } : { mode: "longest"; padding: U; } +>mode : "longest" +>"longest" : "longest" +>padding : U +>b : U +} + +export const a = f1({ a: [1], b: ["a"] }).toArray(); +>a : ({ a: number; b: string; } & {})[] +>f1({ a: [1], b: ["a"] }).toArray() : ({ a: number; b: string; } & {})[] +>f1({ a: [1], b: ["a"] }).toArray : () => ({ a: number; b: string; } & {})[] +>f1({ a: [1], b: ["a"] }) : IteratorObject<{ a: number; b: string; } & {}, undefined, unknown> +>f1 : >>(a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown> +>{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : string[] +>["a"] : string[] +>"a" : "a" +>toArray : () => ({ a: number; b: string; } & {})[] + +export const b = f2({ a: [1], b: ["a"] }).toArray(); +>b : ({ a: number | undefined; b: string | undefined; } & {})[] +>f2({ a: [1], b: ["a"] }).toArray() : ({ a: number | undefined; b: string | undefined; } & {})[] +>f2({ a: [1], b: ["a"] }).toArray : () => ({ a: number | undefined; b: string | undefined; } & {})[] +>f2({ a: [1], b: ["a"] }) : IteratorObject<{ a: number | undefined; b: string | undefined; } & {}, undefined, unknown> +>f2 : >>(a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown> +>{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : string[] +>["a"] : string[] +>"a" : "a" +>toArray : () => ({ a: number | undefined; b: string | undefined; } & {})[] + +export const c = f3({ a: [1], b: ["a"] }).toArray(); +>c : ({ a: number | undefined; b: string | undefined; } & {})[] +>f3({ a: [1], b: ["a"] }).toArray() : ({ a: number | undefined; b: string | undefined; } & {})[] +>f3({ a: [1], b: ["a"] }).toArray : () => ({ a: number | undefined; b: string | undefined; } & {})[] +>f3({ a: [1], b: ["a"] }) : IteratorObject<{ a: number | undefined; b: string | undefined; } & {}, undefined, unknown> +>f3 : >>(a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown> +>{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : string[] +>["a"] : string[] +>"a" : "a" +>toArray : () => ({ a: number | undefined; b: string | undefined; } & {})[] + +export const d = f4({ a: [1], b: ["a"] }).toArray(); +>d : ({ a: number; b: string; } & {})[] +>f4({ a: [1], b: ["a"] }).toArray() : ({ a: number; b: string; } & {})[] +>f4({ a: [1], b: ["a"] }).toArray : () => ({ a: number; b: string; } & {})[] +>f4({ a: [1], b: ["a"] }) : IteratorObject<{ a: number; b: string; } & {}, undefined, unknown> +>f4 : (a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown> +>{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : string[] +>["a"] : string[] +>"a" : "a" +>toArray : () => ({ a: number; b: string; } & {})[] + +export const e = f5([1], 0).toArray(); +>e : ({ a: number; } & {})[] +>f5([1], 0).toArray() : ({ a: number; } & {})[] +>f5([1], 0).toArray : () => ({ a: number; } & {})[] +>f5([1], 0) : IteratorObject<{ a: number; } & {}, undefined, unknown> +>f5 : (a: Iterable, b: T) => IteratorObject<{ a: T; } & {}, undefined, unknown> +>[1] : number[] +>1 : 1 +>0 : 0 +>toArray : () => ({ a: number; } & {})[] + +export const f = f6([[1], ["a"]] as const).toArray(); +>f : [1, "a"][] +>f6([[1], ["a"]] as const).toArray() : [1, "a"][] +>f6([[1], ["a"]] as const).toArray : () => [1, "a"][] +>f6([[1], ["a"]] as const) : IteratorObject<[1, "a"], undefined, unknown> +>f6 : | Iterator)[]>(a: T) => IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown> +>[[1], ["a"]] as const : readonly [readonly [1], readonly ["a"]] +>[[1], ["a"]] : readonly [readonly [1], readonly ["a"]] +>[1] : readonly [1] +>1 : 1 +>["a"] : readonly ["a"] +>"a" : "a" +>toArray : () => [1, "a"][] + +export const g = f7([1], { a: 0 }).toArray(); +>g : ({ a: number; } & {})[] +>f7([1], { a: 0 }).toArray() : ({ a: number; } & {})[] +>f7([1], { a: 0 }).toArray : () => ({ a: number; } & {})[] +>f7([1], { a: 0 }) : IteratorObject<{ a: number; } & {}, undefined, unknown> +>f7 : (a: Iterable, b: U) => IteratorObject<{ a: T | ("a" extends infer T_1 ? T_1 extends "a" ? T_1 extends keyof U ? U[T_1] : never : never : never) | ("a" extends infer T_2 ? T_2 extends "a" ? T_2 extends keyof { [K in keyof U as {} extends Pick ? never : K]: unknown; } ? never : undefined : never : never); } & {}, undefined, unknown> +>[1] : number[] +>1 : 1 +>{ a: 0 } : { a: number; } +>a : number +>0 : 0 +>toArray : () => ({ a: number; } & {})[] + diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=true).js b/tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=true).js new file mode 100644 index 0000000000000..8ffcc3ba08d59 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=true).js @@ -0,0 +1,108 @@ +//// [tests/cases/compiler/iteratorZipDeclarations.ts] //// + +//// [iteratorZipDeclarations.ts] +export function f1>>(a: T) { + return Iterator.zipKeyed(a); +} + +export function f2>>(a: T) { + return Iterator.zipKeyed(a, { mode: "longest" }); +} + +export function f3>>(a: T) { + return Iterator.zipKeyed(a, { mode: "longest", padding: {} }); +} + +export function f4(a: T) { + return Iterator.zipKeyed(a); +} + +export function f5(a: Iterable, b: T) { + return Iterator.zipKeyed({ a }, { mode: "longest", padding: { a: b } }); +} + +export function f6 | Iterator)[]>(a: T) { + return Iterator.zip(a); +} + +export function f7(a: Iterable, b: U) { + return Iterator.zipKeyed({ a }, { mode: "longest", padding: b }); +} + +export const a = f1({ a: [1], b: ["a"] }).toArray(); +export const b = f2({ a: [1], b: ["a"] }).toArray(); +export const c = f3({ a: [1], b: ["a"] }).toArray(); +export const d = f4({ a: [1], b: ["a"] }).toArray(); +export const e = f5([1], 0).toArray(); +export const f = f6([[1], ["a"]] as const).toArray(); +export const g = f7([1], { a: 0 }).toArray(); + + +//// [iteratorZipDeclarations.js] +export function f1(a) { + return Iterator.zipKeyed(a); +} +export function f2(a) { + return Iterator.zipKeyed(a, { mode: "longest" }); +} +export function f3(a) { + return Iterator.zipKeyed(a, { mode: "longest", padding: {} }); +} +export function f4(a) { + return Iterator.zipKeyed(a); +} +export function f5(a, b) { + return Iterator.zipKeyed({ a }, { mode: "longest", padding: { a: b } }); +} +export function f6(a) { + return Iterator.zip(a); +} +export function f7(a, b) { + return Iterator.zipKeyed({ a }, { mode: "longest", padding: b }); +} +export const a = f1({ a: [1], b: ["a"] }).toArray(); +export const b = f2({ a: [1], b: ["a"] }).toArray(); +export const c = f3({ a: [1], b: ["a"] }).toArray(); +export const d = f4({ a: [1], b: ["a"] }).toArray(); +export const e = f5([1], 0).toArray(); +export const f = f6([[1], ["a"]]).toArray(); +export const g = f7([1], { a: 0 }).toArray(); + + +//// [iteratorZipDeclarations.d.ts] +export declare function f1>>(a: T): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; +export declare function f2>>(a: T): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; +export declare function f3>>(a: T): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; +export declare function f4(a: T): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; +export declare function f5(a: Iterable, b: T): IteratorObject<{ + a: T; +} & {}, undefined, unknown>; +export declare function f6 | Iterator)[]>(a: T): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; +export declare function f7(a: Iterable, b: U): IteratorObject<{ + a: T | ("a" extends infer T_1 ? T_1 extends "a" ? T_1 extends keyof U ? U[T_1] : never : never : never) | ("a" extends infer T_2 ? T_2 extends "a" ? T_2 extends keyof { [K in keyof U as {} extends Pick ? never : K]: unknown; } ? never : undefined : never : never); +} & {}, undefined, unknown>; +export declare const a: ({ + a: number; + b: string; +} & {})[]; +export declare const b: ({ + a: number | undefined; + b: string | undefined; +} & {})[]; +export declare const c: ({ + a: number | undefined; + b: string | undefined; +} & {})[]; +export declare const d: ({ + a: number; + b: string; +} & {})[]; +export declare const e: ({ + a: number; +} & {})[]; +export declare const f: [1, "a"][]; +export declare const g: ({ + a: number; +} & {})[]; diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=true).symbols b/tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=true).symbols new file mode 100644 index 0000000000000..0908a94f18793 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=true).symbols @@ -0,0 +1,173 @@ +//// [tests/cases/compiler/iteratorZipDeclarations.ts] //// + +=== iteratorZipDeclarations.ts === +export function f1>>(a: T) { +>f1 : Symbol(f1, Decl(iteratorZipDeclarations.ts, 0, 0)) +>T : Symbol(T, Decl(iteratorZipDeclarations.ts, 0, 19)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 0, 64)) +>T : Symbol(T, Decl(iteratorZipDeclarations.ts, 0, 19)) + + return Iterator.zipKeyed(a); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 0, 64)) +} + +export function f2>>(a: T) { +>f2 : Symbol(f2, Decl(iteratorZipDeclarations.ts, 2, 1)) +>T : Symbol(T, Decl(iteratorZipDeclarations.ts, 4, 19)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 4, 64)) +>T : Symbol(T, Decl(iteratorZipDeclarations.ts, 4, 19)) + + return Iterator.zipKeyed(a, { mode: "longest" }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 4, 64)) +>mode : Symbol(mode, Decl(iteratorZipDeclarations.ts, 5, 33)) +} + +export function f3>>(a: T) { +>f3 : Symbol(f3, Decl(iteratorZipDeclarations.ts, 6, 1)) +>T : Symbol(T, Decl(iteratorZipDeclarations.ts, 8, 19)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 8, 64)) +>T : Symbol(T, Decl(iteratorZipDeclarations.ts, 8, 19)) + + return Iterator.zipKeyed(a, { mode: "longest", padding: {} }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 8, 64)) +>mode : Symbol(mode, Decl(iteratorZipDeclarations.ts, 9, 33)) +>padding : Symbol(padding, Decl(iteratorZipDeclarations.ts, 9, 50)) +} + +export function f4(a: T) { +>f4 : Symbol(f4, Decl(iteratorZipDeclarations.ts, 10, 1)) +>T : Symbol(T, Decl(iteratorZipDeclarations.ts, 12, 19)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 12, 37)) +>T : Symbol(T, Decl(iteratorZipDeclarations.ts, 12, 19)) + + return Iterator.zipKeyed(a); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 12, 37)) +} + +export function f5(a: Iterable, b: T) { +>f5 : Symbol(f5, Decl(iteratorZipDeclarations.ts, 14, 1)) +>T : Symbol(T, Decl(iteratorZipDeclarations.ts, 16, 19)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 16, 22)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>T : Symbol(T, Decl(iteratorZipDeclarations.ts, 16, 19)) +>b : Symbol(b, Decl(iteratorZipDeclarations.ts, 16, 37)) +>T : Symbol(T, Decl(iteratorZipDeclarations.ts, 16, 19)) + + return Iterator.zipKeyed({ a }, { mode: "longest", padding: { a: b } }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 17, 30)) +>mode : Symbol(mode, Decl(iteratorZipDeclarations.ts, 17, 37)) +>padding : Symbol(padding, Decl(iteratorZipDeclarations.ts, 17, 54)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 17, 65)) +>b : Symbol(b, Decl(iteratorZipDeclarations.ts, 16, 37)) +} + +export function f6 | Iterator)[]>(a: T) { +>f6 : Symbol(f6, Decl(iteratorZipDeclarations.ts, 18, 1)) +>T : Symbol(T, Decl(iteratorZipDeclarations.ts, 20, 19)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 20, 81)) +>T : Symbol(T, Decl(iteratorZipDeclarations.ts, 20, 19)) + + return Iterator.zip(a); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 20, 81)) +} + +export function f7(a: Iterable, b: U) { +>f7 : Symbol(f7, Decl(iteratorZipDeclarations.ts, 22, 1)) +>T : Symbol(T, Decl(iteratorZipDeclarations.ts, 24, 19)) +>U : Symbol(U, Decl(iteratorZipDeclarations.ts, 24, 21)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 24, 33)) +>T : Symbol(T, Decl(iteratorZipDeclarations.ts, 24, 19)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 24, 44)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>T : Symbol(T, Decl(iteratorZipDeclarations.ts, 24, 19)) +>b : Symbol(b, Decl(iteratorZipDeclarations.ts, 24, 59)) +>U : Symbol(U, Decl(iteratorZipDeclarations.ts, 24, 21)) + + return Iterator.zipKeyed({ a }, { mode: "longest", padding: b }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 25, 30)) +>mode : Symbol(mode, Decl(iteratorZipDeclarations.ts, 25, 37)) +>padding : Symbol(padding, Decl(iteratorZipDeclarations.ts, 25, 54)) +>b : Symbol(b, Decl(iteratorZipDeclarations.ts, 24, 59)) +} + +export const a = f1({ a: [1], b: ["a"] }).toArray(); +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 28, 12)) +>f1({ a: [1], b: ["a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>f1 : Symbol(f1, Decl(iteratorZipDeclarations.ts, 0, 0)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 28, 21)) +>b : Symbol(b, Decl(iteratorZipDeclarations.ts, 28, 29)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +export const b = f2({ a: [1], b: ["a"] }).toArray(); +>b : Symbol(b, Decl(iteratorZipDeclarations.ts, 29, 12)) +>f2({ a: [1], b: ["a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>f2 : Symbol(f2, Decl(iteratorZipDeclarations.ts, 2, 1)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 29, 21)) +>b : Symbol(b, Decl(iteratorZipDeclarations.ts, 29, 29)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +export const c = f3({ a: [1], b: ["a"] }).toArray(); +>c : Symbol(c, Decl(iteratorZipDeclarations.ts, 30, 12)) +>f3({ a: [1], b: ["a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>f3 : Symbol(f3, Decl(iteratorZipDeclarations.ts, 6, 1)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 30, 21)) +>b : Symbol(b, Decl(iteratorZipDeclarations.ts, 30, 29)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +export const d = f4({ a: [1], b: ["a"] }).toArray(); +>d : Symbol(d, Decl(iteratorZipDeclarations.ts, 31, 12)) +>f4({ a: [1], b: ["a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>f4 : Symbol(f4, Decl(iteratorZipDeclarations.ts, 10, 1)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 31, 21)) +>b : Symbol(b, Decl(iteratorZipDeclarations.ts, 31, 29)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +export const e = f5([1], 0).toArray(); +>e : Symbol(e, Decl(iteratorZipDeclarations.ts, 32, 12)) +>f5([1], 0).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>f5 : Symbol(f5, Decl(iteratorZipDeclarations.ts, 14, 1)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +export const f = f6([[1], ["a"]] as const).toArray(); +>f : Symbol(f, Decl(iteratorZipDeclarations.ts, 33, 12)) +>f6([[1], ["a"]] as const).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>f6 : Symbol(f6, Decl(iteratorZipDeclarations.ts, 18, 1)) +>const : Symbol(const) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +export const g = f7([1], { a: 0 }).toArray(); +>g : Symbol(g, Decl(iteratorZipDeclarations.ts, 34, 12)) +>f7([1], { a: 0 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>f7 : Symbol(f7, Decl(iteratorZipDeclarations.ts, 22, 1)) +>a : Symbol(a, Decl(iteratorZipDeclarations.ts, 34, 26)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=true).types b/tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=true).types new file mode 100644 index 0000000000000..7e764cb63a919 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=true).types @@ -0,0 +1,210 @@ +//// [tests/cases/compiler/iteratorZipDeclarations.ts] //// + +=== iteratorZipDeclarations.ts === +export function f1>>(a: T) { +>f1 : >>(a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown> +>a : T + + return Iterator.zipKeyed(a); +>Iterator.zipKeyed(a) : IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a : T +} + +export function f2>>(a: T) { +>f2 : >>(a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown> +>a : T + + return Iterator.zipKeyed(a, { mode: "longest" }); +>Iterator.zipKeyed(a, { mode: "longest" }) : IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a : T +>{ mode: "longest" } : { mode: "longest"; } +>mode : "longest" +>"longest" : "longest" +} + +export function f3>>(a: T) { +>f3 : >>(a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown> +>a : T + + return Iterator.zipKeyed(a, { mode: "longest", padding: {} }); +>Iterator.zipKeyed(a, { mode: "longest", padding: {} }) : IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a : T +>{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } +>mode : "longest" +>"longest" : "longest" +>padding : {} +>{} : {} +} + +export function f4(a: T) { +>f4 : (a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown> +>a : T + + return Iterator.zipKeyed(a); +>Iterator.zipKeyed(a) : IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>a : T +} + +export function f5(a: Iterable, b: T) { +>f5 : (a: Iterable, b: T) => IteratorObject<{ a: T; } & {}, undefined, unknown> +>a : Iterable +>b : T + + return Iterator.zipKeyed({ a }, { mode: "longest", padding: { a: b } }); +>Iterator.zipKeyed({ a }, { mode: "longest", padding: { a: b } }) : IteratorObject<{ a: T; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a } : { a: Iterable; } +>a : Iterable +>{ mode: "longest", padding: { a: b } } : { mode: "longest"; padding: { a: T; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: T; } +>{ a: b } : { a: T; } +>a : T +>b : T +} + +export function f6 | Iterator)[]>(a: T) { +>f6 : | Iterator)[]>(a: T) => IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown> +>a : T + + return Iterator.zip(a); +>Iterator.zip(a) : IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T_1, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T_1, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T_1, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T_1 extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T_1 extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T_1, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T_1, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T_1, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T_1 extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T_1 extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>a : T +} + +export function f7(a: Iterable, b: U) { +>f7 : (a: Iterable, b: U) => IteratorObject<{ a: T | ("a" extends infer T_1 ? T_1 extends "a" ? T_1 extends keyof U ? U[T_1] : never : never : never) | ("a" extends infer T_2 ? T_2 extends "a" ? T_2 extends keyof { [K in keyof U as {} extends Pick ? never : K]: unknown; } ? never : undefined : never : never); } & {}, undefined, unknown> +>a : T | undefined +>a : Iterable +>b : U + + return Iterator.zipKeyed({ a }, { mode: "longest", padding: b }); +>Iterator.zipKeyed({ a }, { mode: "longest", padding: b }) : IteratorObject<{ a: T | ("a" extends infer T_1 ? T_1 extends "a" ? T_1 extends keyof U ? U[T_1] : never : never : never) | ("a" extends infer T_2 ? T_2 extends "a" ? T_2 extends keyof { [K in keyof U as {} extends Pick ? never : K]: unknown; } ? never : undefined : never : never); } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U_1 : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U_1 : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>{ a } : { a: Iterable; } +>a : Iterable +>{ mode: "longest", padding: b } : { mode: "longest"; padding: U; } +>mode : "longest" +>"longest" : "longest" +>padding : U +>b : U +} + +export const a = f1({ a: [1], b: ["a"] }).toArray(); +>a : ({ a: number; b: string; } & {})[] +>f1({ a: [1], b: ["a"] }).toArray() : ({ a: number; b: string; } & {})[] +>f1({ a: [1], b: ["a"] }).toArray : () => ({ a: number; b: string; } & {})[] +>f1({ a: [1], b: ["a"] }) : IteratorObject<{ a: number; b: string; } & {}, undefined, unknown> +>f1 : >>(a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown> +>{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : string[] +>["a"] : string[] +>"a" : "a" +>toArray : () => ({ a: number; b: string; } & {})[] + +export const b = f2({ a: [1], b: ["a"] }).toArray(); +>b : ({ a: number | undefined; b: string | undefined; } & {})[] +>f2({ a: [1], b: ["a"] }).toArray() : ({ a: number | undefined; b: string | undefined; } & {})[] +>f2({ a: [1], b: ["a"] }).toArray : () => ({ a: number | undefined; b: string | undefined; } & {})[] +>f2({ a: [1], b: ["a"] }) : IteratorObject<{ a: number | undefined; b: string | undefined; } & {}, undefined, unknown> +>f2 : >>(a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown> +>{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : string[] +>["a"] : string[] +>"a" : "a" +>toArray : () => ({ a: number | undefined; b: string | undefined; } & {})[] + +export const c = f3({ a: [1], b: ["a"] }).toArray(); +>c : ({ a: number | undefined; b: string | undefined; } & {})[] +>f3({ a: [1], b: ["a"] }).toArray() : ({ a: number | undefined; b: string | undefined; } & {})[] +>f3({ a: [1], b: ["a"] }).toArray : () => ({ a: number | undefined; b: string | undefined; } & {})[] +>f3({ a: [1], b: ["a"] }) : IteratorObject<{ a: number | undefined; b: string | undefined; } & {}, undefined, unknown> +>f3 : >>(a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown> +>{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : string[] +>["a"] : string[] +>"a" : "a" +>toArray : () => ({ a: number | undefined; b: string | undefined; } & {})[] + +export const d = f4({ a: [1], b: ["a"] }).toArray(); +>d : ({ a: number; b: string; } & {})[] +>f4({ a: [1], b: ["a"] }).toArray() : ({ a: number; b: string; } & {})[] +>f4({ a: [1], b: ["a"] }).toArray : () => ({ a: number; b: string; } & {})[] +>f4({ a: [1], b: ["a"] }) : IteratorObject<{ a: number; b: string; } & {}, undefined, unknown> +>f4 : (a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown> +>{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : string[] +>["a"] : string[] +>"a" : "a" +>toArray : () => ({ a: number; b: string; } & {})[] + +export const e = f5([1], 0).toArray(); +>e : ({ a: number; } & {})[] +>f5([1], 0).toArray() : ({ a: number; } & {})[] +>f5([1], 0).toArray : () => ({ a: number; } & {})[] +>f5([1], 0) : IteratorObject<{ a: number; } & {}, undefined, unknown> +>f5 : (a: Iterable, b: T) => IteratorObject<{ a: T; } & {}, undefined, unknown> +>[1] : number[] +>1 : 1 +>0 : 0 +>toArray : () => ({ a: number; } & {})[] + +export const f = f6([[1], ["a"]] as const).toArray(); +>f : [1, "a"][] +>f6([[1], ["a"]] as const).toArray() : [1, "a"][] +>f6([[1], ["a"]] as const).toArray : () => [1, "a"][] +>f6([[1], ["a"]] as const) : IteratorObject<[1, "a"], undefined, unknown> +>f6 : | Iterator)[]>(a: T) => IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown> +>[[1], ["a"]] as const : readonly [readonly [1], readonly ["a"]] +>[[1], ["a"]] : readonly [readonly [1], readonly ["a"]] +>[1] : readonly [1] +>1 : 1 +>["a"] : readonly ["a"] +>"a" : "a" +>toArray : () => [1, "a"][] + +export const g = f7([1], { a: 0 }).toArray(); +>g : ({ a: number; } & {})[] +>f7([1], { a: 0 }).toArray() : ({ a: number; } & {})[] +>f7([1], { a: 0 }).toArray : () => ({ a: number; } & {})[] +>f7([1], { a: 0 }) : IteratorObject<{ a: number; } & {}, undefined, unknown> +>f7 : (a: Iterable, b: U) => IteratorObject<{ a: T | ("a" extends infer T_1 ? T_1 extends "a" ? T_1 extends keyof U ? U[T_1] : never : never : never) | ("a" extends infer T_2 ? T_2 extends "a" ? T_2 extends keyof { [K in keyof U as {} extends Pick ? never : K]: unknown; } ? never : undefined : never : never); } & {}, undefined, unknown> +>[1] : number[] +>1 : 1 +>{ a: 0 } : { a: number; } +>a : number +>0 : 0 +>toArray : () => ({ a: number; } & {})[] + diff --git a/tsc/testdata/tests/cases/compiler/iteratorChunks.ts b/tsc/testdata/tests/cases/compiler/iteratorChunks.ts index b728167b45387..1ae509b5ecec0 100644 --- a/tsc/testdata/tests/cases/compiler/iteratorChunks.ts +++ b/tsc/testdata/tests/cases/compiler/iteratorChunks.ts @@ -2,6 +2,6 @@ // @lib: es2015, esnext.iterator // @strict: true -const chunks: number[][] = Iterator.from([1, 2, 3]).chunks(2).toArray(); +const a: number[][] = Iterator.from([1, 2, 3]).chunks(2).toArray(); Iterator.from([1, 2, 3]).chunks("2"); diff --git a/tsc/testdata/tests/cases/compiler/iteratorIncludes.ts b/tsc/testdata/tests/cases/compiler/iteratorIncludes.ts index 4df0f336f433e..29846468f87af 100644 --- a/tsc/testdata/tests/cases/compiler/iteratorIncludes.ts +++ b/tsc/testdata/tests/cases/compiler/iteratorIncludes.ts @@ -2,8 +2,8 @@ // @lib: es2015, esnext.iterator // @strict: true -const includes: boolean = Iterator.from([1, 2, 3]).includes(2); -const includesAfterSkipping: boolean = Iterator.from([1, 2, 3]).includes(2, 1); +const a: boolean = Iterator.from([1, 2, 3]).includes(2); +const b: boolean = Iterator.from([1, 2, 3]).includes(2, 1); Iterator.from([1, 2, 3]).includes("1"); diff --git a/tsc/testdata/tests/cases/compiler/iteratorJoin.ts b/tsc/testdata/tests/cases/compiler/iteratorJoin.ts index 9ca68e0037163..61a8cc2de8bf0 100644 --- a/tsc/testdata/tests/cases/compiler/iteratorJoin.ts +++ b/tsc/testdata/tests/cases/compiler/iteratorJoin.ts @@ -2,7 +2,7 @@ // @lib: es2015, esnext.iterator // @strict: true -const joined: string = Iterator.from([1, 2, 3]).join("-"); -const joinedWithDefaultSeparator: string = Iterator.from([1, 2, 3]).join(); +const a: string = Iterator.from([1, 2, 3]).join("-"); +const b: string = Iterator.from([1, 2, 3]).join(); Iterator.from([1, 2, 3]).join(0); diff --git a/tsc/testdata/tests/cases/compiler/iteratorZip.ts b/tsc/testdata/tests/cases/compiler/iteratorZip.ts index 7b34ef3d5eb61..a2ef39a934727 100644 --- a/tsc/testdata/tests/cases/compiler/iteratorZip.ts +++ b/tsc/testdata/tests/cases/compiler/iteratorZip.ts @@ -4,66 +4,66 @@ // @exactOptionalPropertyTypes: true, false // @declaration: true -declare const key: unique symbol; +declare const a1: unique symbol; -const tuples: [number, string][] = Iterator.zip([ +const a2: [number, string][] = Iterator.zip([ [1, 2], new Set(["a", "b"]), ] as const).toArray(); -tuples[0][0] = 2; +a2[0][0] = 2; -const shortestTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray(); -const strictTuples: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray(); -const longestTuplesWithPadding: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray(); -const longestTuplesWithoutPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray(); -const longestTuplesWithPartialPadding: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray(); +const a3: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray(); +const a4: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray(); +const a5: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray(); +const a6: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray(); +const a7: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray(); -declare const maybeLongestOptions: { mode: "shortest"; } | { mode: "longest"; }; -const maybeLongestTuples: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, maybeLongestOptions).toArray(); +declare const a8: { mode: "shortest"; } | { mode: "longest"; }; +const a9: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, a8).toArray(); -const empty: never[] = Iterator.zip([]).toArray(); -const emptyLongest: never[] = Iterator.zip([], { mode: "longest" }).toArray(); +const a10: never[] = Iterator.zip([]).toArray(); +const a11: never[] = Iterator.zip([], { mode: "longest" }).toArray(); -declare const iterables: Iterable>; -const arrays: number[][] = Iterator.zip(iterables).toArray(); -const longestArrays: (number | undefined)[][] = Iterator.zip(iterables, { mode: "longest" }).toArray(); -const maybeLongestArrays: (number | undefined)[][] = Iterator.zip(iterables, maybeLongestOptions).toArray(); +declare const a12: Iterable>; +const a13: number[][] = Iterator.zip(a12).toArray(); +const a14: (number | undefined)[][] = Iterator.zip(a12, { mode: "longest" }).toArray(); +const a15: (number | undefined)[][] = Iterator.zip(a12, a8).toArray(); -declare const iterableArray: Iterable[]; -const longestArrayWithPadding: (number | undefined)[][] = Iterator.zip(iterableArray, { mode: "longest", padding: [] }).toArray(); +declare const a16: Iterable[]; +const a17: (number | undefined)[][] = Iterator.zip(a16, { mode: "longest", padding: [] }).toArray(); -const objects: { a: number; b: string; [key]: boolean; }[] = Iterator.zipKeyed({ +const a18: { a: number; b: string; [a1]: boolean; }[] = Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), - [key]: [true, false], + [a1]: [true, false], } as const).toArray(); -objects[0].a = 2; +a18[0].a = 2; -const longestObjectsWithPadding: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +const a19: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" }, }).toArray(); -const longestObjectsWithoutPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +const a20: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", }).toArray(); -const longestObjectsWithPartialPadding: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { +const a21: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" }, }).toArray(); -const maybeLongestObjects: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, maybeLongestOptions).toArray(); +const a22: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, a8).toArray(); -interface Inputs { +interface I1 { a: Iterable; b: Iterator; } -declare const inputs: Inputs; -const rows: { a: number; b: string; }[] = Iterator.zipKeyed(inputs).toArray(); +declare const a23: I1; +const a24: { a: number; b: string; }[] = Iterator.zipKeyed(a23).toArray(); Iterator.zip([[1]], { mode: "invalid" }); @@ -75,13 +75,11 @@ Iterator.zip(0); Iterator.zipKeyed({ a: 0 }); -const emptyKeyed: never[] = Iterator.zipKeyed({}).toArray(); -const emptyKeyedLongest: never[] = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); +const a25: Record[] = Iterator.zipKeyed({}).toArray(); +const a26: Record[] = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); -declare const unionInputs: { a: Iterable; } | { b: Iterator; }; -const unionRows: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(unionInputs).toArray(); - -// Inputs +declare const a27: { a: Iterable; } | { b: Iterator; }; +const a28: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(a27).toArray(); Iterator.zip("ab"); Iterator.zip(["ab"]); @@ -92,55 +90,55 @@ Iterator.zip([], { mode: "longest", padding: "ab" }); Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); -const a: [string][] = Iterator.zip([new String("ab")]).toArray(); -const b: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); -const c: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); +const a29: [string][] = Iterator.zip([new String("ab")]).toArray(); +const a30: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); +const a31: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); -const d = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); -const e: { a: number; }[] = d; -d[0].b; -const f: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); -const g: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); +const a32 = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); +const a33: { a: number; }[] = a32; +a32[0].b; +const a34: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); +const a35: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); -interface I { +interface I2 { readonly a: Iterable; readonly b?: Iterator; readonly c: Iterable | undefined; readonly d?: undefined; } -declare const h: I; -const i = Iterator.zipKeyed(h).toArray(); -const j: { a: number; b?: string; c?: boolean; }[] = i; -i[0].a = 2; -i[0].b = "a"; -i[0].c = true; -i[0].d; -const k: { a: number; c: boolean; }[] = i; -const l: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(h, { mode: "longest" }).toArray(); - -declare const m: { a: Iterable; } | { b: Iterator; }; -const n: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(m).toArray(); -declare const o: { a: Iterable; } | { b: number; }; -Iterator.zipKeyed(o); -Iterator.zipKeyed(o, { mode: "longest" }); -Iterator.zipKeyed(o, { mode: "longest", padding: {} }); -declare const p: { a?: Iterable; } | { b: string; }; -Iterator.zipKeyed(p); -declare const q: { a: Iterable; } | { b: undefined; }; -const r: { a: number; }[] = Iterator.zipKeyed(q).toArray(); - -declare const s: unique symbol; -declare const t: { a: Iterable; [s]?: Iterable; }; -const u: { a: number; [s]?: string; }[] = Iterator.zipKeyed(t).toArray(); +declare const a36: I2; +const a37 = Iterator.zipKeyed(a36).toArray(); +const a38: { a: number; b?: string; c?: boolean; }[] = a37; +a37[0].a = 2; +a37[0].b = "a"; +a37[0].c = true; +a37[0].d; +const a39: { a: number; c: boolean; }[] = a37; +const a40: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(a36, { mode: "longest" }).toArray(); + +declare const a41: { a: Iterable; } | { b: Iterator; }; +const a42: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(a41).toArray(); +declare const a43: { a: Iterable; } | { b: number; }; +Iterator.zipKeyed(a43); +Iterator.zipKeyed(a43, { mode: "longest" }); +Iterator.zipKeyed(a43, { mode: "longest", padding: {} }); +declare const a44: { a?: Iterable; } | { b: string; }; +Iterator.zipKeyed(a44); +declare const a45: { a: Iterable; } | { b: undefined; }; +const a46: { a: number; }[] = Iterator.zipKeyed(a45).toArray(); + +declare const a47: unique symbol; +declare const a48: { a: Iterable; [a47]?: Iterable; }; +const a49: { a: number; [a47]?: string; }[] = Iterator.zipKeyed(a48).toArray(); Iterator.zipKeyed({ a: [1], b: null }); Iterator.zipKeyed({ a: [1], b: false }); Iterator.zip([undefined]); -declare const v: { a?: undefined; }; -const w: never[] = Iterator.zipKeyed(v).toArray(); -const x: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); -const y: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); +declare const a50: { a?: undefined; }; +const a51: never[] = Iterator.zipKeyed(a50).toArray(); +const a52: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); +const a53: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); function f1(a: Iterable) { const b: { a: T; }[] = Iterator.zipKeyed({ a }).toArray(); @@ -148,122 +146,128 @@ function f1(a: Iterable) { return { b, c }; } -// Padding - -const paddingA: [Iterable, ...Iterable[]] = [[1, 2], [3]]; -const paddingB = Iterator.zip(paddingA, { mode: "longest", padding: [0] }).toArray(); -const paddingC: (number | undefined)[][] = paddingB; -const paddingD: number[][] = paddingB; - -const paddingE: Record> = { a: [1], b: [2, 3] }; -const paddingF = Iterator.zipKeyed(paddingE, { mode: "longest", padding: {} }).toArray(); -const paddingG: Record[] = paddingF; -const paddingH: Record[] = paddingF; - -declare const paddingI: Record; -const paddingJ = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: paddingI }).toArray(); -const paddingK: { a: number | undefined; b: number | undefined; }[] = paddingJ; -const paddingL: { a: number; b: number; }[] = paddingJ; - -const paddingM = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); -const paddingN: [number, string][] = paddingM; -const paddingO = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); -const paddingP: { a: number; b: string; }[] = paddingO; - -const paddingQ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); -const paddingR: [number | undefined, string | undefined][] = paddingQ; -const paddingS: [number, string][] = paddingQ; -const paddingT = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); -const paddingU: { a: number | undefined; b: string | undefined; }[] = paddingT; -const paddingV: { a: number; b: string; }[] = paddingT; - -declare const paddingW: readonly [number, string]; -const paddingX: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingW }).toArray(); -declare const paddingY: [number, string?]; -const paddingZ = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingY }).toArray(); -const paddingA1: [number, string][] = paddingZ; - -declare const paddingB1: [Iterable] | [Iterable, Iterable]; -const paddingC1 = Iterator.zip(paddingB1, { mode: "longest", padding: [0] }).toArray(); -const paddingD1: number[][] = paddingC1; -declare const paddingE1: { a: Iterable; } | { b: Iterable; }; -const paddingF1 = Iterator.zipKeyed(paddingE1, { mode: "longest", padding: { a: 0 } }).toArray(); -const paddingG1: ({ a: number; } | { b: string; })[] = paddingF1; - -declare const paddingH1: { a: number; } | { b: string; }; -const paddingI1 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: paddingH1 }).toArray(); -const paddingJ1: { a: number; b: string; }[] = paddingI1; - -const paddingK1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); -const paddingL1: { a: number; b: number; }[] = paddingK1; - -declare const paddingM1: { [K in `a${string}`]: Iterable; }; -const paddingN1 = Iterator.zipKeyed(paddingM1, { mode: "longest", padding: {} }).toArray(); -const paddingO1: { [K in `a${string}`]: number; }[] = paddingN1; - -declare const paddingP1: unique symbol; -const paddingQ1: { [paddingP1]: number; }[] = Iterator.zipKeyed({ [paddingP1]: [1] }, { mode: "longest", padding: { [paddingP1]: 0 } }).toArray(); - -declare const paddingR1: Record & { a: number; }; -const paddingS1 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: paddingR1 }).toArray(); -const paddingT1: { a: number; b: number | undefined; }[] = paddingS1; -const paddingU1: { a: number; b: number; }[] = paddingS1; - -declare const paddingV1: [number] | [number, string]; -const paddingW1 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: paddingV1 }).toArray(); -const paddingX1: [number, string | undefined][] = paddingW1; -const paddingY1: [number, string][] = paddingW1; - -const paddingZ1: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); -const paddingA2: { a: number | undefined; b: number; }[] = paddingK1; - -// Own properties - -class InputsWithPrototypeMembers { - values = [1, 2]; - - get label() { +const a54: [Iterable, ...Iterable[]] = [[1, 2], [3]]; +const a55 = Iterator.zip(a54, { mode: "longest", padding: [0] }).toArray(); +const a56: (number | undefined)[][] = a55; +const a57: number[][] = a55; + +const a58: Record> = { a: [1], b: [2, 3] }; +const a59 = Iterator.zipKeyed(a58, { mode: "longest", padding: {} }).toArray(); +const a60: Record[] = a59; +const a61: Record[] = a59; + +declare const a62: Record; +const a63 = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a62 }).toArray(); +const a64: { a: number | undefined; b: number | undefined; }[] = a63; +const a65: { a: number; b: number; }[] = a63; + +const a66 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); +const a67: [number, string][] = a66; +const a68 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); +const a69: { a: number; b: string; }[] = a68; + +const a70 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); +const a71: [number | undefined, string | undefined][] = a70; +const a72: [number, string][] = a70; +const a73 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); +const a74: { a: number | undefined; b: string | undefined; }[] = a73; +const a75: { a: number; b: string; }[] = a73; + +declare const a76: readonly [number, string]; +const a77: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a76 }).toArray(); +declare const a78: [number, string?]; +const a79 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a78 }).toArray(); +const a80: [number, string][] = a79; + +declare const a81: [Iterable] | [Iterable, Iterable]; +const a82 = Iterator.zip(a81, { mode: "longest", padding: [0] }).toArray(); +const a83: number[][] = a82; +declare const a84: { a: Iterable; } | { b: Iterable; }; +const a85 = Iterator.zipKeyed(a84, { mode: "longest", padding: { a: 0 } }).toArray(); +const a86: ({ a: number; } | { b: string; })[] = a85; + +declare const a87: { a: number; } | { b: string; }; +const a88 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: a87 }).toArray(); +const a89: { a: number; b: string; }[] = a88; + +const a90 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); +const a91: { a: number; b: number; }[] = a90; + +declare const a92: { [K in `a${string}`]: Iterable; }; +const a93 = Iterator.zipKeyed(a92, { mode: "longest", padding: {} }).toArray(); +const a94: { [K in `a${string}`]: number; }[] = a93; + +declare const a95: unique symbol; +const a96: { [a95]: number; }[] = Iterator.zipKeyed({ [a95]: [1] }, { mode: "longest", padding: { [a95]: 0 } }).toArray(); + +declare const a97: Record & { a: number; }; +const a98 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: a97 }).toArray(); +const a99: { a: number; b: number | undefined; }[] = a98; +const a100: { a: number; b: number; }[] = a98; + +declare const a101: [number] | [number, string]; +const a102 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a101 }).toArray(); +const a103: [number, string | undefined][] = a102; +const a104: [number, string][] = a102; + +const a105: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); +const a106: { a: number | undefined; b: number; }[] = a90; + +class C1 { + a = [1, 2]; + + get b() { return "inputs"; } - describe() { - return this.label; + f() { + return this.b; } } -const instance = new InputsWithPrototypeMembers(); -const inherited = Iterator.zipKeyed(instance).toArray(); -const inheritedStrict = Iterator.zipKeyed(instance, { mode: "strict" }).toArray(); -const inheritedLongest = Iterator.zipKeyed(instance, { mode: "longest" }).toArray(); -const inheritedPadded = Iterator.zipKeyed(instance, { mode: "longest", padding: { values: 0 } }).toArray(); - -const hiddenInputs = { values: [1, 2], label: "inputs" }; -Object.defineProperty(hiddenInputs, "label", { enumerable: false }); -const nonEnumerable = Iterator.zipKeyed(hiddenInputs).toArray(); -const nonEnumerablePadded = Iterator.zipKeyed(hiddenInputs, { mode: "longest", padding: { values: 0 } }).toArray(); - -// The same static shape can have an enumerable non-iterator property instead. -// Such inputs are accepted by the fallback and checked at runtime. -const enumerableInputs = { values: [1, 2], label: "inputs" }; -const enumerable = Iterator.zipKeyed(enumerableInputs).toArray(); - -// The array's length and methods are not enumerable own properties. -const arrayInputs = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); - -// The fallback must not claim that ignored properties exist on yielded objects. -const inheritedLabel: string = inherited[0].label; -const nonEnumerableLabel: string = nonEnumerable[0].label; - -// Precise record inference still handles symbol keys and padding. -declare const ownKey: unique symbol; -const precise: { values: number; [ownKey]: string; }[] = Iterator.zipKeyed({ values: [1], [ownKey]: ["a"] }).toArray(); -const preciseLongest: { values: number | undefined; }[] = Iterator.zipKeyed({ values: [1] }, { mode: "longest" }).toArray(); -const precisePadded: { values: number; }[] = Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: 0 } }).toArray(); -const emptyOwnProperties: never[] = Iterator.zipKeyed({}).toArray(); +const a107 = new C1(); +const a108 = Iterator.zipKeyed(a107).toArray(); +const a109 = Iterator.zipKeyed(a107, { mode: "strict" }).toArray(); +const a110 = Iterator.zipKeyed(a107, { mode: "longest" }).toArray(); +const a111 = Iterator.zipKeyed(a107, { mode: "longest", padding: { a: 0 } }).toArray(); + +const a112 = { a: [1, 2], b: "inputs" }; +Object.defineProperty(a112, "b", { enumerable: false }); +const a113 = Iterator.zipKeyed(a112).toArray(); +const a114 = Iterator.zipKeyed(a112, { mode: "longest", padding: { a: 0 } }).toArray(); + +const a115 = { a: [1, 2], b: "inputs" }; +const a116 = Iterator.zipKeyed(a115).toArray(); + +const a117 = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); + +const a118: string = a108[0].b; +const a119: string = a113[0].b; + +declare const a120: unique symbol; +const a121: { a: number; [a120]: string; }[] = Iterator.zipKeyed({ a: [1], [a120]: ["a"] }).toArray(); +const a122: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1] }, { mode: "longest" }).toArray(); +const a123: { a: number; }[] = Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray(); + +declare const a124: object; +const a125 = Iterator.zipKeyed(a124).toArray(); +const a126 = Iterator.zipKeyed(a124, { mode: "strict" }).toArray(); +const a127 = Iterator.zipKeyed(a124, { mode: "longest" }).toArray(); +const a128 = Iterator.zipKeyed(a124, { mode: "longest", padding: { a: 0 } }).toArray(); +const a129: unknown = a125[0].a; +const a130: unknown = a126[0].a; +const a131: unknown = a127[0].a; +const a132: unknown = a128[0].a; +const a133: never[] = a125; + +declare const a134: {}; +const a135 = Iterator.zipKeyed(a134).toArray(); +const a136: unknown = a135[0].a; +const a137: never[] = a135; Iterator.zipKeyed(0); Iterator.zipKeyed(null); -Iterator.zipKeyed(instance, { mode: "invalid" }); -Iterator.zipKeyed(instance, { mode: "shortest", padding: {} }); -Iterator.zipKeyed(instance, { mode: "longest", padding: 0 }); -Iterator.zipKeyed({ values: [1] }, { mode: "longest", padding: { values: "invalid" } }); +Iterator.zipKeyed(a107, { mode: "invalid" }); +Iterator.zipKeyed(a107, { mode: "shortest", padding: {} }); +Iterator.zipKeyed(a107, { mode: "longest", padding: 0 }); +Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: "invalid" } }); diff --git a/tsc/testdata/tests/cases/compiler/iteratorZipDeclarations.ts b/tsc/testdata/tests/cases/compiler/iteratorZipDeclarations.ts new file mode 100644 index 0000000000000..8d7d2ed6e669f --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/iteratorZipDeclarations.ts @@ -0,0 +1,41 @@ +// @target: esnext +// @lib: es2015, esnext.iterator +// @strict: true +// @exactOptionalPropertyTypes: true, false +// @declaration: true + +export function f1>>(a: T) { + return Iterator.zipKeyed(a); +} + +export function f2>>(a: T) { + return Iterator.zipKeyed(a, { mode: "longest" }); +} + +export function f3>>(a: T) { + return Iterator.zipKeyed(a, { mode: "longest", padding: {} }); +} + +export function f4(a: T) { + return Iterator.zipKeyed(a); +} + +export function f5(a: Iterable, b: T) { + return Iterator.zipKeyed({ a }, { mode: "longest", padding: { a: b } }); +} + +export function f6 | Iterator)[]>(a: T) { + return Iterator.zip(a); +} + +export function f7(a: Iterable, b: U) { + return Iterator.zipKeyed({ a }, { mode: "longest", padding: b }); +} + +export const a = f1({ a: [1], b: ["a"] }).toArray(); +export const b = f2({ a: [1], b: ["a"] }).toArray(); +export const c = f3({ a: [1], b: ["a"] }).toArray(); +export const d = f4({ a: [1], b: ["a"] }).toArray(); +export const e = f5([1], 0).toArray(); +export const f = f6([[1], ["a"]] as const).toArray(); +export const g = f7([1], { a: 0 }).toArray(); From 34817bdf6bc714a7d8dca6af072c53addbbc8f33 Mon Sep 17 00:00:00 2001 From: Oleksandr Tarasiuk Date: Wed, 7 Oct 2026 15:40:29 +0300 Subject: [PATCH 8/8] fix iterator zip padding types --- .../bundled/libs/lib.esnext.iterator.d.ts | 37 +- ...actoptionalpropertytypes=false).errors.txt | 286 ++- ...orZip(exactoptionalpropertytypes=false).js | 395 +++- ...(exactoptionalpropertytypes=false).symbols | 1635 +++++++++++------ ...ip(exactoptionalpropertytypes=false).types | 1302 ++++++++++--- ...xactoptionalpropertytypes=true).errors.txt | 290 ++- ...torZip(exactoptionalpropertytypes=true).js | 395 +++- ...p(exactoptionalpropertytypes=true).symbols | 1635 +++++++++++------ ...Zip(exactoptionalpropertytypes=true).types | 1302 ++++++++++--- ...tions(exactoptionalpropertytypes=false).js | 108 -- ...(exactoptionalpropertytypes=false).symbols | 173 -- ...ns(exactoptionalpropertytypes=false).types | 210 --- ...ations(exactoptionalpropertytypes=true).js | 108 -- ...s(exactoptionalpropertytypes=true).symbols | 173 -- ...ons(exactoptionalpropertytypes=true).types | 210 --- .../tests/cases/compiler/iteratorZip.ts | 99 +- .../cases/compiler/iteratorZipDeclarations.ts | 41 - 17 files changed, 5684 insertions(+), 2715 deletions(-) delete mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=false).js delete mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=false).symbols delete mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=false).types delete mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=true).js delete mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=true).symbols delete mode 100644 tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=true).types delete mode 100644 tsc/testdata/tests/cases/compiler/iteratorZipDeclarations.ts diff --git a/tsc/internal/bundled/libs/lib.esnext.iterator.d.ts b/tsc/internal/bundled/libs/lib.esnext.iterator.d.ts index 94154a585b6f4..3b13ecd4ec47a 100644 --- a/tsc/internal/bundled/libs/lib.esnext.iterator.d.ts +++ b/tsc/internal/bundled/libs/lib.esnext.iterator.d.ts @@ -18,14 +18,14 @@ and limitations under the License. export {}; -interface IteratorZipShortestOptions { +type IteratorZipShortestOptions = { /** * Stops when any input is exhausted. */ - mode?: "shortest"; -} + mode?: "shortest" | undefined; +}; -interface IteratorZipLongestOptions { +type IteratorZipLongestOptions = { /** * Continues until every input is exhausted. */ @@ -34,16 +34,16 @@ interface IteratorZipLongestOptions { /** * Values used when an input is exhausted before the others. */ - padding?: T; -} + padding?: (T & object) | undefined; +}; -interface IteratorZipStrictOptions { +type IteratorZipStrictOptions = { /** * Requires every input to yield the same number of values. * If not, a `TypeError` will be thrown when an input is exhausted before others. */ mode: "strict"; -} +}; type IteratorZipOptions = | IteratorZipShortestOptions @@ -54,18 +54,21 @@ type IteratorInput = (Iterable | Iterator) & object; type IteratorYield = T extends IteratorInput ? U : never; -type IteratorZipPadding = { +type IteratorZipKey = K extends number ? K | `${K}` | (number extends K ? "NaN" | "Infinity" | "-Infinity" : never) + : K extends `${infer N extends number}` ? `${N}` extends K ? K | N : K : K; + +type IteratorZipDefaultPadding = { readonly [K in keyof T]?: IteratorYield | undefined; }; type IteratorZipPaddingKeys = keyof { - [K in keyof T as {} extends Pick ? never : K]: unknown; + [K in keyof T as {} extends Pick ? never : IteratorZipKey]: unknown; }; type IteratorZipValue = | IteratorYield - | (K extends keyof TPadding ? TPadding[K] : never) - | (K extends IteratorZipPaddingKeys ? never : TExtra); + | (TPadding extends unknown ? TPadding[IteratorZipKey & keyof TPadding] | (K extends "NaN" | "Infinity" | "-Infinity" ? TPadding[number & keyof TPadding] : never) : never) + | (IteratorZipKey extends IteratorZipPaddingKeys ? never : TExtra); type IteratorZipResult = { -readonly [K in keyof T]: IteratorZipValue; @@ -116,8 +119,8 @@ declare global { * @param options Controls how differing input lengths are handled. */ zip[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; - zip[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer>; }): IteratorObject, undefined, unknown>; - zip[] | []>(iterables: T, options: IteratorZipOptions>>): IteratorObject, undefined, unknown>; + zip[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding; }): IteratorObject, undefined, unknown>; + zip[] | [], TPadding extends readonly unknown[] | [] = IteratorZipDefaultPadding>(iterables: T, options?: IteratorZipOptions): IteratorObject>, undefined, unknown>; /** * Creates an iterator whose values are arrays containing values yielded at the same position by each input iterator or iterable. @@ -125,7 +128,7 @@ declare global { * @param options Controls how differing input lengths are handled. */ zip>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject[], undefined, unknown>; - zip>(iterables: Iterable & object, options: IteratorZipOptions | undefined> & object>>): IteratorObject<(IteratorYield | undefined)[], undefined, unknown>; + zip, TPadding = IteratorYield>(iterables: Iterable & object, options?: IteratorZipOptions & object>): IteratorObject<(IteratorYield | TPadding | undefined)[], undefined, unknown>; /** * Creates an iterator whose values are objects containing values yielded at the same position by each iterator or iterable in the input object. @@ -133,8 +136,8 @@ declare global { * @param options Controls how differing input lengths are handled. */ zipKeyed(iterables: T & IteratorZipKeyedInput, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; - zipKeyed(iterables: T & IteratorZipKeyedInput, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer>; }): IteratorObject, undefined, unknown>; - zipKeyed(iterables: T & IteratorZipKeyedInput, options: IteratorZipOptions & object>>): IteratorObject, undefined, unknown>; + zipKeyed(iterables: T & IteratorZipKeyedInput, options: IteratorZipLongestOptions & { padding: TPadding; }): IteratorObject, undefined, unknown>; + zipKeyed>(iterables: T & IteratorZipKeyedInput, options?: IteratorZipOptions): IteratorObject>, undefined, unknown>; /** * Accepts objects whose types include inherited or non-enumerable properties. diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).errors.txt b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).errors.txt index e763ab7eda746..1a857ef1e79a6 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).errors.txt @@ -1,27 +1,18 @@ -iteratorZip.ts(62,23): error TS2769: No overload matches this call. +a.ts(62,23): error TS2769: No overload matches this call. The last overload gave the following error. Type '"invalid"' is not assignable to type '"longest" | "shortest" | "strict" | undefined'. -iteratorZip.ts(64,56): error TS2769: No overload matches this call. - The last overload gave the following error. - Type 'true[]' is not assignable to type 'Iterable<"a" | 1 | undefined> & object'. - Type 'true[]' is not assignable to type 'Iterable<"a" | 1 | undefined>'. - The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. - Type 'IteratorResult' is not assignable to type 'IteratorResult<"a" | 1 | undefined, any>'. - Type 'IteratorYieldResult' is not assignable to type 'IteratorResult<"a" | 1 | undefined, any>'. - Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult<"a" | 1 | undefined>'. - Type 'true' is not assignable to type '"a" | 1 | undefined'. -iteratorZip.ts(66,41): error TS2769: No overload matches this call. +a.ts(64,41): error TS2769: No overload matches this call. The last overload gave the following error. Object literal may only specify known properties, and 'padding' does not exist in type 'IteratorZipShortestOptions'. -iteratorZip.ts(68,14): error TS2769: No overload matches this call. +a.ts(66,14): error TS2769: No overload matches this call. The last overload gave the following error. Argument of type 'number' is not assignable to parameter of type 'Iterable> & object'. Type 'number' is not assignable to type 'Iterable>'. -iteratorZip.ts(78,14): error TS2769: No overload matches this call. +a.ts(76,14): error TS2769: No overload matches this call. The last overload gave the following error. Argument of type 'string' is not assignable to parameter of type 'Iterable> & object'. Type 'string' is not assignable to type 'Iterable>'. -iteratorZip.ts(79,14): error TS2769: No overload matches this call. +a.ts(77,14): error TS2769: No overload matches this call. The last overload gave the following error. Argument of type 'string[]' is not assignable to parameter of type 'Iterable> & object'. Type 'string[]' is not assignable to type 'Iterable>'. @@ -30,7 +21,7 @@ iteratorZip.ts(79,14): error TS2769: No overload matches this call. Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>'. Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>'. Type 'string' is not assignable to type 'IteratorInput'. -iteratorZip.ts(80,14): error TS2769: No overload matches this call. +a.ts(78,14): error TS2769: No overload matches this call. The last overload gave the following error. Argument of type 'Set' is not assignable to parameter of type 'Iterable> & object'. Type 'Set' is not assignable to type 'Iterable>'. @@ -39,28 +30,28 @@ iteratorZip.ts(80,14): error TS2769: No overload matches this call. Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>'. Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>'. Type 'string' is not assignable to type 'IteratorInput'. -iteratorZip.ts(81,19): error TS2769: No overload matches this call. +a.ts(79,19): error TS2769: No overload matches this call. The last overload gave the following error. Argument of type '"ab"' is not assignable to parameter of type 'never'. -iteratorZip.ts(83,37): error TS2769: No overload matches this call. +a.ts(81,37): error TS2769: No overload matches this call. The last overload gave the following error. - Type 'string' is not assignable to type 'Iterable & object'. - Type 'string' is not assignable to type 'Iterable'. -iteratorZip.ts(84,42): error TS2769: No overload matches this call. + Type 'string' is not assignable to type 'Iterable & object'. + Type 'string' is not assignable to type 'object'. +a.ts(82,42): error TS2769: No overload matches this call. The last overload gave the following error. - Type 'string' is not assignable to type 'Iterable & object'. + Type 'string' is not assignable to type 'Iterable & object'. Type 'string' is not assignable to type 'object'. -iteratorZip.ts(85,19): error TS2769: No overload matches this call. +a.ts(83,19): error TS2769: No overload matches this call. The last overload gave the following error. Argument of type '{}' is not assignable to parameter of type 'never'. -iteratorZip.ts(93,8): error TS2339: Property 'b' does not exist on type '{ a: number; } & {}'. -iteratorZip.ts(109,8): error TS2339: Property 'd' does not exist on type '{ a: number; } & { b?: string | undefined; c?: IteratorZipValue | undefined, "c", never, {}> | undefined; }'. -iteratorZip.ts(110,7): error TS2322: Type '({ a: number; } & { b?: string | undefined; c?: IteratorZipValue | undefined, "c", never, {}> | undefined; })[]' is not assignable to type '{ a: number; c: boolean; }[]'. +a.ts(91,8): error TS2339: Property 'b' does not exist on type '{ a: number; } & {}'. +a.ts(107,8): error TS2339: Property 'd' does not exist on type '{ a: number; } & { b?: string | undefined; c?: IteratorZipValue | undefined, "c", never, {}> | undefined; }'. +a.ts(108,7): error TS2322: Type '({ a: number; } & { b?: string | undefined; c?: IteratorZipValue | undefined, "c", never, {}> | undefined; })[]' is not assignable to type '{ a: number; c: boolean; }[]'. Type '{ a: number; } & { b?: string | undefined; c?: IteratorZipValue | undefined, "c", never, {}> | undefined; }' is not assignable to type '{ a: number; c: boolean; }'. Types of property 'c' are incompatible. Type 'boolean | undefined' is not assignable to type 'boolean'. Type 'undefined' is not assignable to type 'boolean'. -iteratorZip.ts(130,14): error TS2769: No overload matches this call. +a.ts(128,14): error TS2769: No overload matches this call. The last overload gave the following error. Argument of type 'undefined[]' is not assignable to parameter of type 'Iterable> & object'. Type 'undefined[]' is not assignable to type 'Iterable>'. @@ -69,99 +60,134 @@ iteratorZip.ts(130,14): error TS2769: No overload matches this call. Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>'. Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>'. Type 'undefined' is not assignable to type 'IteratorInput'. -iteratorZip.ts(146,7): error TS2322: Type '[number, ...IteratorZipValue, number, undefined, [number]>[]][]' is not assignable to type 'number[][]'. +a.ts(144,7): error TS2322: Type '[number, ...IteratorZipValue, number, undefined, [number]>[]][]' is not assignable to type 'number[][]'. Type '[number, ...IteratorZipValue, number, undefined, [number]>[]]' is not assignable to type 'number[]'. Type 'IteratorZipValue, number, undefined, [number]>' is not assignable to type 'number'. Type 'undefined' is not assignable to type 'number'. -iteratorZip.ts(151,7): error TS2322: Type '({ [x: string]: IteratorZipValue, string, undefined, {}>; } & {})[]' is not assignable to type 'Record[]'. +a.ts(149,7): error TS2322: Type '({ [x: string]: IteratorZipValue, string, undefined, {}>; } & {})[]' is not assignable to type 'Record[]'. Type '{ [x: string]: IteratorZipValue, string, undefined, {}>; } & {}' is not assignable to type 'Record'. 'string' index signatures are incompatible. Type 'IteratorZipValue, string, undefined, {}>' is not assignable to type 'number'. Type 'undefined' is not assignable to type 'number'. -iteratorZip.ts(156,7): error TS2322: Type '({ a: IteratorZipValue>; b: IteratorZipValue>; } & {})[]' is not assignable to type '{ a: number; b: number; }[]'. +a.ts(154,7): error TS2322: Type '({ a: IteratorZipValue>; b: IteratorZipValue>; } & {})[]' is not assignable to type '{ a: number; b: number; }[]'. Type '{ a: IteratorZipValue>; b: IteratorZipValue>; } & {}' is not assignable to type '{ a: number; b: number; }'. Types of property 'a' are incompatible. Type 'IteratorZipValue>' is not assignable to type 'number'. Type 'undefined' is not assignable to type 'number'. -iteratorZip.ts(165,7): error TS2322: Type '[number, IteratorZipValue][]' is not assignable to type '[number, string][]'. +a.ts(163,7): error TS2322: Type '[number, IteratorZipValue][]' is not assignable to type '[number, string][]'. Type '[number, IteratorZipValue]' is not assignable to type '[number, string]'. Type at position 1 in source is not compatible with type at position 1 in target. Type 'IteratorZipValue' is not assignable to type 'string'. Type 'undefined' is not assignable to type 'string'. -iteratorZip.ts(168,7): error TS2322: Type '({ a: number; b: IteratorZipValue; } & {})[]' is not assignable to type '{ a: number; b: string; }[]'. +a.ts(166,7): error TS2322: Type '({ a: number; b: IteratorZipValue; } & {})[]' is not assignable to type '{ a: number; b: string; }[]'. Type '{ a: number; b: IteratorZipValue; } & {}' is not assignable to type '{ a: number; b: string; }'. Types of property 'b' are incompatible. Type 'IteratorZipValue' is not assignable to type 'string'. Type 'undefined' is not assignable to type 'string'. -iteratorZip.ts(174,7): error TS2322: Type '[number, IteratorZipValue][]' is not assignable to type '[number, string][]'. +a.ts(172,7): error TS2322: Type '[number, IteratorZipValue][]' is not assignable to type '[number, string][]'. Type '[number, IteratorZipValue]' is not assignable to type '[number, string]'. Type at position 1 in source is not compatible with type at position 1 in target. Type 'IteratorZipValue' is not assignable to type 'string'. Type 'undefined' is not assignable to type 'string'. -iteratorZip.ts(178,7): error TS2322: Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>[]' is not assignable to type 'number[][]'. +a.ts(176,7): error TS2322: Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>[]' is not assignable to type 'number[][]'. Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>' is not assignable to type 'number[]'. Type '[number, IteratorZipValue, "1", undefined, [number]>]' is not assignable to type 'number[]'. Type 'IteratorZipValue, "1", undefined, [number]>' is not assignable to type 'number'. Type 'undefined' is not assignable to type 'number'. -iteratorZip.ts(181,7): error TS2322: Type '(({ a: number; } & {}) | ({ b: IteratorZipValue, "b", undefined, { a: number; }>; } & {}))[]' is not assignable to type '({ a: number; } | { b: string; })[]'. +a.ts(179,7): error TS2322: Type '(({ a: number; } & {}) | ({ b: IteratorZipValue, "b", undefined, { a: number; }>; } & {}))[]' is not assignable to type '({ a: number; } | { b: string; })[]'. Type '({ a: number; } & {}) | ({ b: IteratorZipValue, "b", undefined, { a: number; }>; } & {})' is not assignable to type '{ a: number; } | { b: string; }'. Type '{ b: IteratorZipValue, "b", undefined, { a: number; }>; } & {}' is not assignable to type '{ a: number; } | { b: string; }'. Type '{ b: IteratorZipValue, "b", undefined, { a: number; }>; } & {}' is not assignable to type '{ b: string; }'. Types of property 'b' are incompatible. Type 'IteratorZipValue, "b", undefined, { a: number; }>' is not assignable to type 'string'. Type 'undefined' is not assignable to type 'string'. -iteratorZip.ts(185,7): error TS2322: Type '({ a: IteratorZipValue; b: IteratorZipValue; } & {})[]' is not assignable to type '{ a: number; b: string; }[]'. +a.ts(183,7): error TS2322: Type '({ a: IteratorZipValue; b: IteratorZipValue; } & {})[]' is not assignable to type '{ a: number; b: string; }[]'. Type '{ a: IteratorZipValue; b: IteratorZipValue; } & {}' is not assignable to type '{ a: number; b: string; }'. Types of property 'a' are incompatible. Type 'IteratorZipValue' is not assignable to type 'number'. Type 'undefined' is not assignable to type 'number'. -iteratorZip.ts(188,7): error TS2322: Type '({ a: IteratorZipValue; b: number; } & {})[]' is not assignable to type '{ a: number; b: number; }[]'. +a.ts(186,7): error TS2322: Type '({ a: IteratorZipValue; b: number; } & {})[]' is not assignable to type '{ a: number; b: number; }[]'. Type '{ a: IteratorZipValue; b: number; } & {}' is not assignable to type '{ a: number; b: number; }'. Types of property 'a' are incompatible. Type 'IteratorZipValue' is not assignable to type 'number'. Type 'undefined' is not assignable to type 'number'. -iteratorZip.ts(192,7): error TS2322: Type '({ [x: `a${string}`]: IteratorZipValue, `a${string}`, undefined, {}>; } & {})[]' is not assignable to type '{ [x: `a${string}`]: number; }[]'. +a.ts(190,7): error TS2322: Type '({ [x: `a${string}`]: IteratorZipValue, `a${string}`, undefined, {}>; } & {})[]' is not assignable to type '{ [x: `a${string}`]: number; }[]'. Type '{ [x: `a${string}`]: IteratorZipValue, `a${string}`, undefined, {}>; } & {}' is not assignable to type '{ [x: `a${string}`]: number; }'. '`a${string}`' index signatures are incompatible. Type 'IteratorZipValue, `a${string}`, undefined, {}>' is not assignable to type 'number'. Type 'undefined' is not assignable to type 'number'. -iteratorZip.ts(200,7): error TS2322: Type '({ a: number; b: IteratorZipValue & { a: number; }>; } & {})[]' is not assignable to type '{ a: number; b: number; }[]'. +a.ts(198,7): error TS2322: Type '({ a: number; b: IteratorZipValue & { a: number; }>; } & {})[]' is not assignable to type '{ a: number; b: number; }[]'. Type '{ a: number; b: IteratorZipValue & { a: number; }>; } & {}' is not assignable to type '{ a: number; b: number; }'. Types of property 'b' are incompatible. Type 'IteratorZipValue & { a: number; }>' is not assignable to type 'number'. Type 'undefined' is not assignable to type 'number'. -iteratorZip.ts(205,7): error TS2322: Type '[number, IteratorZipValue][]' is not assignable to type '[number, string][]'. +a.ts(203,7): error TS2322: Type '[number, IteratorZipValue][]' is not assignable to type '[number, string][]'. Type '[number, IteratorZipValue]' is not assignable to type '[number, string]'. Type at position 1 in source is not compatible with type at position 1 in target. Type 'IteratorZipValue' is not assignable to type 'string'. Type 'undefined' is not assignable to type 'string'. -iteratorZip.ts(238,7): error TS2322: Type 'unknown' is not assignable to type 'string'. -iteratorZip.ts(239,7): error TS2322: Type 'unknown' is not assignable to type 'string'. -iteratorZip.ts(255,7): error TS2322: Type 'Record[]' is not assignable to type 'never[]'. +a.ts(236,7): error TS2322: Type 'unknown' is not assignable to type 'string'. +a.ts(237,7): error TS2322: Type 'unknown' is not assignable to type 'string'. +a.ts(253,7): error TS2322: Type 'Record[]' is not assignable to type 'never[]'. Type 'Record' is not assignable to type 'never'. -iteratorZip.ts(260,7): error TS2322: Type 'Record[]' is not assignable to type 'never[]'. +a.ts(258,7): error TS2322: Type 'Record[]' is not assignable to type 'never[]'. Type 'Record' is not assignable to type 'never'. -iteratorZip.ts(262,19): error TS2769: No overload matches this call. +a.ts(260,19): error TS2769: No overload matches this call. The last overload gave the following error. Argument of type '0' is not assignable to parameter of type 'never'. -iteratorZip.ts(263,19): error TS2769: No overload matches this call. +a.ts(261,19): error TS2769: No overload matches this call. The last overload gave the following error. Argument of type 'null' is not assignable to parameter of type 'never'. -iteratorZip.ts(264,27): error TS2769: No overload matches this call. +a.ts(262,27): error TS2769: No overload matches this call. The last overload gave the following error. Type '"invalid"' is not assignable to type '"longest" | "shortest" | "strict" | undefined'. -iteratorZip.ts(265,45): error TS2769: No overload matches this call. +a.ts(263,45): error TS2769: No overload matches this call. The last overload gave the following error. Object literal may only specify known properties, and 'padding' does not exist in type 'IteratorZipShortestOptions'. -iteratorZip.ts(266,44): error TS2769: No overload matches this call. +a.ts(264,44): error TS2769: No overload matches this call. The last overload gave the following error. Type 'number' is not assignable to type 'object'. -iteratorZip.ts(267,19): error TS2769: No overload matches this call. +a.ts(272,7): error TS2322: Type '(number | boolean | undefined)[][]' is not assignable to type '(number | undefined)[][]'. + Type '(number | boolean | undefined)[]' is not assignable to type '(number | undefined)[]'. + Type 'number | boolean | undefined' is not assignable to type 'number | undefined'. + Type 'boolean' is not assignable to type 'number'. +a.ts(278,7): error TS2322: Type '({ a: IteratorZipValue; b: IteratorZipValue; } & {})[]' is not assignable to type '{ a: number | undefined; b: number | undefined; }[]'. + Type '{ a: IteratorZipValue; b: IteratorZipValue; } & {}' is not assignable to type '{ a: number | undefined; b: number | undefined; }'. + Types of property 'a' are incompatible. + Type 'IteratorZipValue' is not assignable to type 'number | undefined'. + Type 'boolean' is not assignable to type 'number'. +a.ts(285,7): error TS2322: Type '({ a: IteratorZipValue>; } & {})[]' is not assignable to type '{ a: number | boolean; }[]'. + Type '{ a: IteratorZipValue>; } & {}' is not assignable to type '{ a: number | boolean; }'. + Types of property 'a' are incompatible. + Type 'IteratorZipValue>' is not assignable to type 'number | boolean'. + Type 'undefined' is not assignable to type 'number | boolean'. +a.ts(299,7): error TS2322: Type '({ 0: IteratorZipValue; } & {})[]' is not assignable to type '{ 0: number; }[]'. + Type '{ 0: IteratorZipValue; } & {}' is not assignable to type '{ 0: number; }'. + Types of property '0' are incompatible. + Type 'IteratorZipValue' is not assignable to type 'number'. + Type 'undefined' is not assignable to type 'number'. +a.ts(304,7): error TS2322: Type '({ NaN: IteratorZipValue>; Infinity: IteratorZipValue>; "-Infinity": IteratorZipValue>; } & {})[]' is not assignable to type '{ NaN: number | undefined; Infinity: number | undefined; "-Infinity": number | undefined; }[]'. + Type '{ NaN: IteratorZipValue>; Infinity: IteratorZipValue>; "-Infinity": IteratorZipValue>; } & {}' is not assignable to type '{ NaN: number | undefined; Infinity: number | undefined; "-Infinity": number | undefined; }'. + Types of property 'NaN' are incompatible. + Type 'IteratorZipValue>' is not assignable to type 'number | undefined'. + Type 'boolean' is not assignable to type 'number'. +a.ts(307,7): error TS2322: Type '({ [x: string]: IteratorZipValue, string, undefined, { a: boolean; }>; } & {})[]' is not assignable to type 'Record[]'. + Type '{ [x: string]: IteratorZipValue, string, undefined, { a: boolean; }>; } & {}' is not assignable to type 'Record'. + 'string' index signatures are incompatible. + Type 'IteratorZipValue, string, undefined, { a: boolean; }>' is not assignable to type 'number | undefined'. + Type 'boolean' is not assignable to type 'number'. +a.ts(314,45): error TS2769: No overload matches this call. The last overload gave the following error. Argument of type '{ a: number[]; }' is not assignable to parameter of type 'never'. +a.ts(315,23): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type '{}' is not assignable to parameter of type 'never'. +a.ts(316,80): error TS2769: No overload matches this call. + The last overload gave the following error. + Type 'number' is not assignable to type 'object'. -==== iteratorZip.ts (38 errors) ==== +==== a.ts (45 errors) ==== declare const a1: unique symbol; const a2: [number, string][] = Iterator.zip([ @@ -228,19 +254,6 @@ iteratorZip.ts(267,19): error TS2769: No overload matches this call. !!! error TS2769: No overload matches this call. !!! error TS2769: The last overload gave the following error. !!! error TS2769: Type '"invalid"' is not assignable to type '"longest" | "shortest" | "strict" | undefined'. -!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. - - Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }); - ~~~~~~~ -!!! error TS2769: No overload matches this call. -!!! error TS2769: The last overload gave the following error. -!!! error TS2769: Type 'true[]' is not assignable to type 'Iterable<"a" | 1 | undefined> & object'. -!!! error TS2769: Type 'true[]' is not assignable to type 'Iterable<"a" | 1 | undefined>'. -!!! error TS2769: The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. -!!! error TS2769: Type 'IteratorResult' is not assignable to type 'IteratorResult<"a" | 1 | undefined, any>'. -!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorResult<"a" | 1 | undefined, any>'. -!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult<"a" | 1 | undefined>'. -!!! error TS2769: Type 'true' is not assignable to type '"a" | 1 | undefined'. !!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. Iterator.zip([[1]], { mode: "shortest", padding: [1] }); @@ -308,14 +321,14 @@ iteratorZip.ts(267,19): error TS2769: No overload matches this call. ~~~~~~~ !!! error TS2769: No overload matches this call. !!! error TS2769: The last overload gave the following error. -!!! error TS2769: Type 'string' is not assignable to type 'Iterable & object'. -!!! error TS2769: Type 'string' is not assignable to type 'Iterable'. +!!! error TS2769: Type 'string' is not assignable to type 'Iterable & object'. +!!! error TS2769: Type 'string' is not assignable to type 'object'. !!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); ~~~~~~~ !!! error TS2769: No overload matches this call. !!! error TS2769: The last overload gave the following error. -!!! error TS2769: Type 'string' is not assignable to type 'Iterable & object'. +!!! error TS2769: Type 'string' is not assignable to type 'Iterable & object'. !!! error TS2769: Type 'string' is not assignable to type 'object'. !!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); @@ -640,10 +653,147 @@ iteratorZip.ts(267,19): error TS2769: No overload matches this call. !!! error TS2769: The last overload gave the following error. !!! error TS2769: Type 'number' is not assignable to type 'object'. !!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. - Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: "invalid" } }); - ~~~~~~~~~~ + const a138: [number | boolean, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }).toArray(); + const a139: { a: number | string; b: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: { a: "a" } }).toArray(); + + declare const a140: boolean[]; + const a141: [number | boolean | undefined, string | boolean | undefined][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a140 }).toArray(); + const a142 = Iterator.zip(a12, { mode: "longest", padding: new Set([false]) }).toArray(); + const a143: (number | boolean | undefined)[][] = a142; + const a144: (number | undefined)[][] = a142; + ~~~~ +!!! error TS2322: Type '(number | boolean | undefined)[][]' is not assignable to type '(number | undefined)[][]'. +!!! error TS2322: Type '(number | boolean | undefined)[]' is not assignable to type '(number | undefined)[]'. +!!! error TS2322: Type 'number | boolean | undefined' is not assignable to type 'number | undefined'. +!!! error TS2322: Type 'boolean' is not assignable to type 'number'. + const a145: (number | boolean | undefined)[][] = Iterator.zip([[1], [2, 3]], { mode: "longest", padding: new Set([false]) }).toArray(); + + declare const a146: { a: boolean; } | { b: string; }; + const a147 = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a146 }).toArray(); + const a148: { a: number | boolean | undefined; b: number | string | undefined; }[] = a147; + const a149: { a: number | undefined; b: number | undefined; }[] = a147; + ~~~~ +!!! error TS2322: Type '({ a: IteratorZipValue; b: IteratorZipValue; } & {})[]' is not assignable to type '{ a: number | undefined; b: number | undefined; }[]'. +!!! error TS2322: Type '{ a: IteratorZipValue; b: IteratorZipValue; } & {}' is not assignable to type '{ a: number | undefined; b: number | undefined; }'. +!!! error TS2322: Types of property 'a' are incompatible. +!!! error TS2322: Type 'IteratorZipValue' is not assignable to type 'number | undefined'. +!!! error TS2322: Type 'boolean' is not assignable to type 'number'. + declare const a150: [boolean] | [string, string]; + const a151: [number | boolean | string, number | string | undefined][] = Iterator.zip([[1], [2, 3]], { mode: "longest", padding: a150 }).toArray(); + + declare const a152: { mode: "longest"; padding?: { a: boolean; }; }; + const a153 = Iterator.zipKeyed({ a: [1] }, a152).toArray(); + const a154: { a: number | boolean | undefined; }[] = a153; + const a155: { a: number | boolean; }[] = a153; + ~~~~ +!!! error TS2322: Type '({ a: IteratorZipValue>; } & {})[]' is not assignable to type '{ a: number | boolean; }[]'. +!!! error TS2322: Type '{ a: IteratorZipValue>; } & {}' is not assignable to type '{ a: number | boolean; }'. +!!! error TS2322: Types of property 'a' are incompatible. +!!! error TS2322: Type 'IteratorZipValue>' is not assignable to type 'number | boolean'. +!!! error TS2322: Type 'undefined' is not assignable to type 'number | boolean'. + declare const a156: { mode: "shortest"; } | { mode: "longest"; padding: [boolean]; } | undefined; + const a157: [number | boolean | undefined][] = Iterator.zip([[1]], a156).toArray(); + const a158: [number][] = Iterator.zip([[1]], { mode: undefined }).toArray(); + const a159: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: undefined }).toArray(); + + const a160: { a: number | { b: string; }; [a1]: boolean | string; }[] = Iterator.zipKeyed({ a: [1], [a1]: [true, false] }, { + mode: "longest", + padding: { a: { b: "a" }, [a1]: "a" }, + }).toArray(); + const a161: { "0": number | boolean; }[] = Iterator.zipKeyed({ "0": [1] }, { mode: "longest", padding: { 0: false } }).toArray(); + const a162: { 0: number | boolean; }[] = Iterator.zipKeyed({ 0: [1] }, { mode: "longest", padding: { "0": false } }).toArray(); + const a163 = Iterator.zipKeyed({ 0: [1] }, { mode: "longest", padding: { "01": false } }).toArray(); + const a164: { 0: number | undefined; }[] = a163; + const a165: { 0: number; }[] = a163; + ~~~~ +!!! error TS2322: Type '({ 0: IteratorZipValue; } & {})[]' is not assignable to type '{ 0: number; }[]'. +!!! error TS2322: Type '{ 0: IteratorZipValue; } & {}' is not assignable to type '{ 0: number; }'. +!!! error TS2322: Types of property '0' are incompatible. +!!! error TS2322: Type 'IteratorZipValue' is not assignable to type 'number'. +!!! error TS2322: Type 'undefined' is not assignable to type 'number'. + + declare const a166: Record; + const a167 = Iterator.zipKeyed({ NaN: [1], Infinity: [2], "-Infinity": [3] }, { mode: "longest", padding: a166 }).toArray(); + const a168: { NaN: number | boolean | undefined; Infinity: number | boolean | undefined; "-Infinity": number | boolean | undefined; }[] = a167; + const a169: { NaN: number | undefined; Infinity: number | undefined; "-Infinity": number | undefined; }[] = a167; + ~~~~ +!!! error TS2322: Type '({ NaN: IteratorZipValue>; Infinity: IteratorZipValue>; "-Infinity": IteratorZipValue>; } & {})[]' is not assignable to type '{ NaN: number | undefined; Infinity: number | undefined; "-Infinity": number | undefined; }[]'. +!!! error TS2322: Type '{ NaN: IteratorZipValue>; Infinity: IteratorZipValue>; "-Infinity": IteratorZipValue>; } & {}' is not assignable to type '{ NaN: number | undefined; Infinity: number | undefined; "-Infinity": number | undefined; }'. +!!! error TS2322: Types of property 'NaN' are incompatible. +!!! error TS2322: Type 'IteratorZipValue>' is not assignable to type 'number | undefined'. +!!! error TS2322: Type 'boolean' is not assignable to type 'number'. + const a170 = Iterator.zipKeyed(a58, { mode: "longest", padding: { a: false } }).toArray(); + const a171: Record[] = a170; + const a172: Record[] = a170; + ~~~~ +!!! error TS2322: Type '({ [x: string]: IteratorZipValue, string, undefined, { a: boolean; }>; } & {})[]' is not assignable to type 'Record[]'. +!!! error TS2322: Type '{ [x: string]: IteratorZipValue, string, undefined, { a: boolean; }>; } & {}' is not assignable to type 'Record'. +!!! error TS2322: 'string' index signatures are incompatible. +!!! error TS2322: Type 'IteratorZipValue, string, undefined, { a: boolean; }>' is not assignable to type 'number | undefined'. +!!! error TS2322: Type 'boolean' is not assignable to type 'number'. + + const a173: [number | undefined, string | undefined][] = Iterator.zip<[Iterable, Iterable]>([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); + const a174: (number | undefined)[][] = Iterator.zip>(a12, { mode: "longest", padding: [0] }).toArray(); + const a175: { a: number | undefined; }[] = Iterator.zipKeyed<{ a: Iterable; }>({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray(); + const a176: [number | boolean][] = Iterator.zip<[Iterable], [boolean]>([[1]], { mode: "longest", padding: [false] }).toArray(); + const a177: { a: number | boolean; }[] = Iterator.zipKeyed<{ a: Iterable; }, { a: boolean; }>({ a: [1] }, { mode: "longest", padding: { a: false } }).toArray(); + Iterator.zipKeyed<{ a: Iterable; }>({ a: [1] }, { mode: "longest", padding: 0 }); + ~~~~~~~~~~ !!! error TS2769: No overload matches this call. !!! error TS2769: The last overload gave the following error. !!! error TS2769: Argument of type '{ a: number[]; }' is not assignable to parameter of type 'never'. !!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + Iterator.zipKeyed<{}>({}, { mode: "longest", padding: 0 }); + ~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type '{}' is not assignable to parameter of type 'never'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + Iterator.zipKeyed<{ a: Iterable; }, {}>({ a: [1] }, { mode: "longest", padding: 0 }); + ~~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Type 'number' is not assignable to type 'object'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + +==== b.ts (0 errors) ==== + export function f1>>(a: T) { + return Iterator.zipKeyed(a); + } + + export function f2>>(a: T) { + return Iterator.zipKeyed(a, { mode: "longest" }); + } + + export function f3>>(a: T) { + return Iterator.zipKeyed(a, { mode: "longest", padding: {} }); + } + + export function f4(a: T) { + return Iterator.zipKeyed(a); + } + + export function f5(a: Iterable, b: U) { + return Iterator.zipKeyed({ a }, { mode: "longest", padding: { a: b } }); + } + + export function f6 | Iterator)[]>(a: T) { + return Iterator.zip(a); + } + + export function f7(a: Iterable, b: U) { + return Iterator.zipKeyed({ a }, { mode: "longest", padding: b }); + } + + export const a = f1({ a: [1], b: ["a"] }).toArray(); + export const b = f2({ a: [1], b: ["a"] }).toArray(); + export const c = f3({ a: [1], b: ["a"] }).toArray(); + export const d = f4({ a: [1], b: ["a"] }).toArray(); + export const e = f5([1], false).toArray(); + export const f = f6([[1], ["a"]] as const).toArray(); + export const g = f7([1], { a: false }).toArray(); + export const h = Iterator.zip; + export const i = Iterator.zipKeyed; + export const j = h([[1], ["a"]], { mode: "longest", padding: [false, false] }).toArray(); + export const k = i({ a: [1], b: [2, 3] }, { mode: "longest", padding: { a: false } }).toArray(); \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).js b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).js index c4b800dd43ba0..70e0990099eff 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).js +++ b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).js @@ -1,6 +1,6 @@ //// [tests/cases/compiler/iteratorZip.ts] //// -//// [iteratorZip.ts] +//// [a.ts] declare const a1: unique symbol; const a2: [number, string][] = Iterator.zip([ @@ -64,8 +64,6 @@ const a24: { a: number; b: string; }[] = Iterator.zipKeyed(a23).toArray(); Iterator.zip([[1]], { mode: "invalid" }); -Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }); - Iterator.zip([[1]], { mode: "shortest", padding: [1] }); Iterator.zip(0); @@ -267,10 +265,102 @@ Iterator.zipKeyed(null); Iterator.zipKeyed(a107, { mode: "invalid" }); Iterator.zipKeyed(a107, { mode: "shortest", padding: {} }); Iterator.zipKeyed(a107, { mode: "longest", padding: 0 }); -Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: "invalid" } }); +const a138: [number | boolean, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }).toArray(); +const a139: { a: number | string; b: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: { a: "a" } }).toArray(); + +declare const a140: boolean[]; +const a141: [number | boolean | undefined, string | boolean | undefined][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a140 }).toArray(); +const a142 = Iterator.zip(a12, { mode: "longest", padding: new Set([false]) }).toArray(); +const a143: (number | boolean | undefined)[][] = a142; +const a144: (number | undefined)[][] = a142; +const a145: (number | boolean | undefined)[][] = Iterator.zip([[1], [2, 3]], { mode: "longest", padding: new Set([false]) }).toArray(); + +declare const a146: { a: boolean; } | { b: string; }; +const a147 = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a146 }).toArray(); +const a148: { a: number | boolean | undefined; b: number | string | undefined; }[] = a147; +const a149: { a: number | undefined; b: number | undefined; }[] = a147; +declare const a150: [boolean] | [string, string]; +const a151: [number | boolean | string, number | string | undefined][] = Iterator.zip([[1], [2, 3]], { mode: "longest", padding: a150 }).toArray(); + +declare const a152: { mode: "longest"; padding?: { a: boolean; }; }; +const a153 = Iterator.zipKeyed({ a: [1] }, a152).toArray(); +const a154: { a: number | boolean | undefined; }[] = a153; +const a155: { a: number | boolean; }[] = a153; +declare const a156: { mode: "shortest"; } | { mode: "longest"; padding: [boolean]; } | undefined; +const a157: [number | boolean | undefined][] = Iterator.zip([[1]], a156).toArray(); +const a158: [number][] = Iterator.zip([[1]], { mode: undefined }).toArray(); +const a159: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: undefined }).toArray(); + +const a160: { a: number | { b: string; }; [a1]: boolean | string; }[] = Iterator.zipKeyed({ a: [1], [a1]: [true, false] }, { + mode: "longest", + padding: { a: { b: "a" }, [a1]: "a" }, +}).toArray(); +const a161: { "0": number | boolean; }[] = Iterator.zipKeyed({ "0": [1] }, { mode: "longest", padding: { 0: false } }).toArray(); +const a162: { 0: number | boolean; }[] = Iterator.zipKeyed({ 0: [1] }, { mode: "longest", padding: { "0": false } }).toArray(); +const a163 = Iterator.zipKeyed({ 0: [1] }, { mode: "longest", padding: { "01": false } }).toArray(); +const a164: { 0: number | undefined; }[] = a163; +const a165: { 0: number; }[] = a163; + +declare const a166: Record; +const a167 = Iterator.zipKeyed({ NaN: [1], Infinity: [2], "-Infinity": [3] }, { mode: "longest", padding: a166 }).toArray(); +const a168: { NaN: number | boolean | undefined; Infinity: number | boolean | undefined; "-Infinity": number | boolean | undefined; }[] = a167; +const a169: { NaN: number | undefined; Infinity: number | undefined; "-Infinity": number | undefined; }[] = a167; +const a170 = Iterator.zipKeyed(a58, { mode: "longest", padding: { a: false } }).toArray(); +const a171: Record[] = a170; +const a172: Record[] = a170; + +const a173: [number | undefined, string | undefined][] = Iterator.zip<[Iterable, Iterable]>([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); +const a174: (number | undefined)[][] = Iterator.zip>(a12, { mode: "longest", padding: [0] }).toArray(); +const a175: { a: number | undefined; }[] = Iterator.zipKeyed<{ a: Iterable; }>({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray(); +const a176: [number | boolean][] = Iterator.zip<[Iterable], [boolean]>([[1]], { mode: "longest", padding: [false] }).toArray(); +const a177: { a: number | boolean; }[] = Iterator.zipKeyed<{ a: Iterable; }, { a: boolean; }>({ a: [1] }, { mode: "longest", padding: { a: false } }).toArray(); +Iterator.zipKeyed<{ a: Iterable; }>({ a: [1] }, { mode: "longest", padding: 0 }); +Iterator.zipKeyed<{}>({}, { mode: "longest", padding: 0 }); +Iterator.zipKeyed<{ a: Iterable; }, {}>({ a: [1] }, { mode: "longest", padding: 0 }); + +//// [b.ts] +export function f1>>(a: T) { + return Iterator.zipKeyed(a); +} + +export function f2>>(a: T) { + return Iterator.zipKeyed(a, { mode: "longest" }); +} + +export function f3>>(a: T) { + return Iterator.zipKeyed(a, { mode: "longest", padding: {} }); +} + +export function f4(a: T) { + return Iterator.zipKeyed(a); +} + +export function f5(a: Iterable, b: U) { + return Iterator.zipKeyed({ a }, { mode: "longest", padding: { a: b } }); +} + +export function f6 | Iterator)[]>(a: T) { + return Iterator.zip(a); +} + +export function f7(a: Iterable, b: U) { + return Iterator.zipKeyed({ a }, { mode: "longest", padding: b }); +} + +export const a = f1({ a: [1], b: ["a"] }).toArray(); +export const b = f2({ a: [1], b: ["a"] }).toArray(); +export const c = f3({ a: [1], b: ["a"] }).toArray(); +export const d = f4({ a: [1], b: ["a"] }).toArray(); +export const e = f5([1], false).toArray(); +export const f = f6([[1], ["a"]] as const).toArray(); +export const g = f7([1], { a: false }).toArray(); +export const h = Iterator.zip; +export const i = Iterator.zipKeyed; +export const j = h([[1], ["a"]], { mode: "longest", padding: [false, false] }).toArray(); +export const k = i({ a: [1], b: [2, 3] }, { mode: "longest", padding: { a: false } }).toArray(); -//// [iteratorZip.js] +//// [a.js] "use strict"; const a2 = Iterator.zip([ [1, 2], @@ -309,7 +399,6 @@ const a21 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { const a22 = Iterator.zipKeyed({ a: [1], b: ["a"] }, a8).toArray(); const a24 = Iterator.zipKeyed(a23).toArray(); Iterator.zip([[1]], { mode: "invalid" }); -Iterator.zip([[1], ["a"]], { mode: "longest", padding: [true] }); Iterator.zip([[1]], { mode: "shortest", padding: [1] }); Iterator.zip(0); Iterator.zipKeyed({ a: 0 }); @@ -444,10 +533,82 @@ Iterator.zipKeyed(null); Iterator.zipKeyed(a107, { mode: "invalid" }); Iterator.zipKeyed(a107, { mode: "shortest", padding: {} }); Iterator.zipKeyed(a107, { mode: "longest", padding: 0 }); -Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: "invalid" } }); +const a138 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [true] }).toArray(); +const a139 = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: { a: "a" } }).toArray(); +const a141 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a140 }).toArray(); +const a142 = Iterator.zip(a12, { mode: "longest", padding: new Set([false]) }).toArray(); +const a143 = a142; +const a144 = a142; +const a145 = Iterator.zip([[1], [2, 3]], { mode: "longest", padding: new Set([false]) }).toArray(); +const a147 = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a146 }).toArray(); +const a148 = a147; +const a149 = a147; +const a151 = Iterator.zip([[1], [2, 3]], { mode: "longest", padding: a150 }).toArray(); +const a153 = Iterator.zipKeyed({ a: [1] }, a152).toArray(); +const a154 = a153; +const a155 = a153; +const a157 = Iterator.zip([[1]], a156).toArray(); +const a158 = Iterator.zip([[1]], { mode: undefined }).toArray(); +const a159 = Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: undefined }).toArray(); +const a160 = Iterator.zipKeyed({ a: [1], [a1]: [true, false] }, { + mode: "longest", + padding: { a: { b: "a" }, [a1]: "a" }, +}).toArray(); +const a161 = Iterator.zipKeyed({ "0": [1] }, { mode: "longest", padding: { 0: false } }).toArray(); +const a162 = Iterator.zipKeyed({ 0: [1] }, { mode: "longest", padding: { "0": false } }).toArray(); +const a163 = Iterator.zipKeyed({ 0: [1] }, { mode: "longest", padding: { "01": false } }).toArray(); +const a164 = a163; +const a165 = a163; +const a167 = Iterator.zipKeyed({ NaN: [1], Infinity: [2], "-Infinity": [3] }, { mode: "longest", padding: a166 }).toArray(); +const a168 = a167; +const a169 = a167; +const a170 = Iterator.zipKeyed(a58, { mode: "longest", padding: { a: false } }).toArray(); +const a171 = a170; +const a172 = a170; +const a173 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); +const a174 = Iterator.zip(a12, { mode: "longest", padding: [0] }).toArray(); +const a175 = Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray(); +const a176 = Iterator.zip([[1]], { mode: "longest", padding: [false] }).toArray(); +const a177 = Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: false } }).toArray(); +Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: 0 }); +Iterator.zipKeyed({}, { mode: "longest", padding: 0 }); +Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: 0 }); +//// [b.js] +export function f1(a) { + return Iterator.zipKeyed(a); +} +export function f2(a) { + return Iterator.zipKeyed(a, { mode: "longest" }); +} +export function f3(a) { + return Iterator.zipKeyed(a, { mode: "longest", padding: {} }); +} +export function f4(a) { + return Iterator.zipKeyed(a); +} +export function f5(a, b) { + return Iterator.zipKeyed({ a }, { mode: "longest", padding: { a: b } }); +} +export function f6(a) { + return Iterator.zip(a); +} +export function f7(a, b) { + return Iterator.zipKeyed({ a }, { mode: "longest", padding: b }); +} +export const a = f1({ a: [1], b: ["a"] }).toArray(); +export const b = f2({ a: [1], b: ["a"] }).toArray(); +export const c = f3({ a: [1], b: ["a"] }).toArray(); +export const d = f4({ a: [1], b: ["a"] }).toArray(); +export const e = f5([1], false).toArray(); +export const f = f6([[1], ["a"]]).toArray(); +export const g = f7([1], { a: false }).toArray(); +export const h = Iterator.zip; +export const i = Iterator.zipKeyed; +export const j = h([[1], ["a"]], { mode: "longest", padding: [false, false] }).toArray(); +export const k = i({ a: [1], b: [2, 3] }, { mode: "longest", padding: { a: false } }).toArray(); -//// [iteratorZip.d.ts] +//// [a.d.ts] declare const a1: unique symbol; declare const a2: [number, string][]; declare const a3: [number, string][]; @@ -782,3 +943,221 @@ declare const a134: {}; declare const a135: Record[]; declare const a136: unknown; declare const a137: never[]; +declare const a138: [number | boolean, string | undefined][]; +declare const a139: { + a: number | string; + b: number | undefined; +}[]; +declare const a140: boolean[]; +declare const a141: [number | boolean | undefined, string | boolean | undefined][]; +declare const a142: (number | boolean | undefined)[][]; +declare const a143: (number | boolean | undefined)[][]; +declare const a144: (number | undefined)[][]; +declare const a145: (number | boolean | undefined)[][]; +declare const a146: { + a: boolean; +} | { + b: string; +}; +declare const a147: ({ + a: number | boolean | undefined; + b: string | number | undefined; +} & {})[]; +declare const a148: { + a: number | boolean | undefined; + b: number | string | undefined; +}[]; +declare const a149: { + a: number | undefined; + b: number | undefined; +}[]; +declare const a150: [boolean] | [string, string]; +declare const a151: [number | boolean | string, number | string | undefined][]; +declare const a152: { + mode: "longest"; + padding?: { + a: boolean; + }; +}; +declare const a153: ({ + a: number | boolean | undefined; +} & {})[]; +declare const a154: { + a: number | boolean | undefined; +}[]; +declare const a155: { + a: number | boolean; +}[]; +declare const a156: { + mode: "shortest"; +} | { + mode: "longest"; + padding: [boolean]; +} | undefined; +declare const a157: [number | boolean | undefined][]; +declare const a158: [number][]; +declare const a159: { + a: number | undefined; +}[]; +declare const a160: { + a: number | { + b: string; + }; + [a1]: boolean | string; +}[]; +declare const a161: { + "0": number | boolean; +}[]; +declare const a162: { + 0: number | boolean; +}[]; +declare const a163: ({ + 0: number | undefined; +} & {})[]; +declare const a164: { + 0: number | undefined; +}[]; +declare const a165: { + 0: number; +}[]; +declare const a166: Record; +declare const a167: ({ + NaN: number | boolean | undefined; + Infinity: number | boolean | undefined; + "-Infinity": number | boolean | undefined; +} & {})[]; +declare const a168: { + NaN: number | boolean | undefined; + Infinity: number | boolean | undefined; + "-Infinity": number | boolean | undefined; +}[]; +declare const a169: { + NaN: number | undefined; + Infinity: number | undefined; + "-Infinity": number | undefined; +}[]; +declare const a170: ({ + [x: string]: number | boolean | undefined; +} & {})[]; +declare const a171: Record[]; +declare const a172: Record[]; +declare const a173: [number | undefined, string | undefined][]; +declare const a174: (number | undefined)[][]; +declare const a175: { + a: number | undefined; +}[]; +declare const a176: [number | boolean][]; +declare const a177: { + a: number | boolean; +}[]; +//// [b.d.ts] +export declare function f1>>(a: T): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; +export declare function f2>>(a: T): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> extends infer T_2 ? T_2 extends Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> as {} extends Pick | Iterator) & object ? U : never : never : never) | undefined; }>, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> extends infer T_2 ? T_2 extends Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> as {} extends Pick | Iterator) & object ? U : never : never : never) | undefined; }>, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; +export declare function f3>>(a: T): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : undefined)) | undefined; }, undefined, unknown>; +export declare function f4(a: T): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; +export declare function f5(a: Iterable, b: U): IteratorObject<{ + a: T | U; +} & {}, undefined, unknown>; +export declare function f6 | Iterator)[]>(a: T): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; +export declare function f7(a: Iterable, b: U): IteratorObject<{ + a: T | (U extends unknown ? U["a" & keyof U] : never) | ("a" extends keyof { [K in keyof U as {} extends Pick ? never : K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K]: unknown; } ? never : undefined); +} & {}, undefined, unknown>; +export declare const a: ({ + a: number; + b: string; +} & {})[]; +export declare const b: ({ + a: number | undefined; + b: string | undefined; +} & {})[]; +export declare const c: ({ + a: number | undefined; + b: string | undefined; +} & {})[]; +export declare const d: ({ + a: number; + b: string; +} & {})[]; +export declare const e: ({ + a: number | boolean; +} & {})[]; +export declare const f: [1, "a"][]; +export declare const g: ({ + a: number | boolean; +} & {})[]; +export declare const h: { + (iterables: readonly [], options?: { + mode: "longest"; + padding?: (Iterable & object) | undefined; + } | { + mode?: "shortest" | undefined; + } | { + mode: "strict"; + }): IteratorObject; + | Iterator) & object)[] | []>(iterables: T, options?: { + mode?: "shortest" | undefined; + } | { + mode: "strict"; + }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; + | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { + mode: "longest"; + padding?: (TPadding & object) | undefined; + } & { + padding: TPadding; + }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; + | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ + mode: "longest"; + padding?: (TPadding & object) | undefined; + } | { + mode?: "shortest" | undefined; + } | { + mode: "strict"; + }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; + | Iterator) & object>(iterables: Iterable & object, options?: { + mode?: "shortest" | undefined; + } | { + mode: "strict"; + }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; + | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ + mode: "longest"; + padding?: (Iterable & object) | undefined; + } | { + mode?: "shortest" | undefined; + } | { + mode: "strict"; + }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; +}; +export declare const i: { + (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { + mode?: "shortest" | undefined; + } | { + mode: "strict"; + }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; + (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { + mode: "longest"; + padding?: (TPadding & object) | undefined; + } & { + padding: TPadding; + }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; + | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ + mode: "longest"; + padding?: (TPadding & object) | undefined; + } | { + mode?: "shortest" | undefined; + } | { + mode: "strict"; + }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; + (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { + mode: "longest"; + padding?: object | undefined; + } | { + mode?: "shortest" | undefined; + } | { + mode: "strict"; + }): IteratorObject, undefined, unknown>; +}; +export declare const j: [number | boolean, string | boolean][]; +export declare const k: ({ + a: number | boolean; + b: number | undefined; +} & {})[]; diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).symbols b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).symbols index 14821dd34b801..6ce9848b374fa 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).symbols +++ b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).symbols @@ -1,11 +1,11 @@ //// [tests/cases/compiler/iteratorZip.ts] //// -=== iteratorZip.ts === +=== a.ts === declare const a1: unique symbol; ->a1 : Symbol(a1, Decl(iteratorZip.ts, 0, 13)) +>a1 : Symbol(a1, Decl(a.ts, 0, 13)) const a2: [number, string][] = Iterator.zip([ ->a2 : Symbol(a2, Decl(iteratorZip.ts, 2, 5)) +>a2 : Symbol(a2, Decl(a.ts, 2, 5)) >Iterator.zip([ [1, 2], new Set(["a", "b"]),] as const).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) @@ -20,78 +20,78 @@ const a2: [number, string][] = Iterator.zip([ >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) a2[0][0] = 2; ->a2 : Symbol(a2, Decl(iteratorZip.ts, 2, 5)) +>a2 : Symbol(a2, Decl(a.ts, 2, 5)) >0 : Symbol(0) const a3: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray(); ->a3 : Symbol(a3, Decl(iteratorZip.ts, 9, 5)) +>a3 : Symbol(a3, Decl(a.ts, 9, 5)) >Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >const : Symbol(const) ->mode : Symbol(mode, Decl(iteratorZip.ts, 9, 68)) +>mode : Symbol(mode, Decl(a.ts, 9, 68)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a4: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray(); ->a4 : Symbol(a4, Decl(iteratorZip.ts, 10, 5)) +>a4 : Symbol(a4, Decl(a.ts, 10, 5)) >Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >const : Symbol(const) ->mode : Symbol(mode, Decl(iteratorZip.ts, 10, 68)) +>mode : Symbol(mode, Decl(a.ts, 10, 68)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a5: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray(); ->a5 : Symbol(a5, Decl(iteratorZip.ts, 11, 5)) +>a5 : Symbol(a5, Decl(a.ts, 11, 5)) >Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >const : Symbol(const) ->mode : Symbol(mode, Decl(iteratorZip.ts, 11, 68)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 11, 85)) +>mode : Symbol(mode, Decl(a.ts, 11, 68)) +>padding : Symbol(padding, Decl(a.ts, 11, 85)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a6: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray(); ->a6 : Symbol(a6, Decl(iteratorZip.ts, 12, 5)) +>a6 : Symbol(a6, Decl(a.ts, 12, 5)) >Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >const : Symbol(const) ->mode : Symbol(mode, Decl(iteratorZip.ts, 12, 92)) +>mode : Symbol(mode, Decl(a.ts, 12, 92)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a7: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray(); ->a7 : Symbol(a7, Decl(iteratorZip.ts, 13, 5)) +>a7 : Symbol(a7, Decl(a.ts, 13, 5)) >Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >const : Symbol(const) ->mode : Symbol(mode, Decl(iteratorZip.ts, 13, 92)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 13, 109)) +>mode : Symbol(mode, Decl(a.ts, 13, 92)) +>padding : Symbol(padding, Decl(a.ts, 13, 109)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) declare const a8: { mode: "shortest"; } | { mode: "longest"; }; ->a8 : Symbol(a8, Decl(iteratorZip.ts, 15, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 15, 19)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 15, 43)) +>a8 : Symbol(a8, Decl(a.ts, 15, 13)) +>mode : Symbol(mode, Decl(a.ts, 15, 19)) +>mode : Symbol(mode, Decl(a.ts, 15, 43)) const a9: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, a8).toArray(); ->a9 : Symbol(a9, Decl(iteratorZip.ts, 16, 5)) +>a9 : Symbol(a9, Decl(a.ts, 16, 5)) >Iterator.zip([[1], ["a"]] as const, a8).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >const : Symbol(const) ->a8 : Symbol(a8, Decl(iteratorZip.ts, 15, 13)) +>a8 : Symbol(a8, Decl(a.ts, 15, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a10: never[] = Iterator.zip([]).toArray(); ->a10 : Symbol(a10, Decl(iteratorZip.ts, 18, 5)) +>a10 : Symbol(a10, Decl(a.ts, 18, 5)) >Iterator.zip([]).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) @@ -99,218 +99,210 @@ const a10: never[] = Iterator.zip([]).toArray(); >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a11: never[] = Iterator.zip([], { mode: "longest" }).toArray(); ->a11 : Symbol(a11, Decl(iteratorZip.ts, 19, 5)) +>a11 : Symbol(a11, Decl(a.ts, 19, 5)) >Iterator.zip([], { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 19, 39)) +>mode : Symbol(mode, Decl(a.ts, 19, 39)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) declare const a12: Iterable>; ->a12 : Symbol(a12, Decl(iteratorZip.ts, 21, 13)) +>a12 : Symbol(a12, Decl(a.ts, 21, 13)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) const a13: number[][] = Iterator.zip(a12).toArray(); ->a13 : Symbol(a13, Decl(iteratorZip.ts, 22, 5)) +>a13 : Symbol(a13, Decl(a.ts, 22, 5)) >Iterator.zip(a12).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->a12 : Symbol(a12, Decl(iteratorZip.ts, 21, 13)) +>a12 : Symbol(a12, Decl(a.ts, 21, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a14: (number | undefined)[][] = Iterator.zip(a12, { mode: "longest" }).toArray(); ->a14 : Symbol(a14, Decl(iteratorZip.ts, 23, 5)) +>a14 : Symbol(a14, Decl(a.ts, 23, 5)) >Iterator.zip(a12, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->a12 : Symbol(a12, Decl(iteratorZip.ts, 21, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 23, 57)) +>a12 : Symbol(a12, Decl(a.ts, 21, 13)) +>mode : Symbol(mode, Decl(a.ts, 23, 57)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a15: (number | undefined)[][] = Iterator.zip(a12, a8).toArray(); ->a15 : Symbol(a15, Decl(iteratorZip.ts, 24, 5)) +>a15 : Symbol(a15, Decl(a.ts, 24, 5)) >Iterator.zip(a12, a8).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->a12 : Symbol(a12, Decl(iteratorZip.ts, 21, 13)) ->a8 : Symbol(a8, Decl(iteratorZip.ts, 15, 13)) +>a12 : Symbol(a12, Decl(a.ts, 21, 13)) +>a8 : Symbol(a8, Decl(a.ts, 15, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) declare const a16: Iterable[]; ->a16 : Symbol(a16, Decl(iteratorZip.ts, 26, 13)) +>a16 : Symbol(a16, Decl(a.ts, 26, 13)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) const a17: (number | undefined)[][] = Iterator.zip(a16, { mode: "longest", padding: [] }).toArray(); ->a17 : Symbol(a17, Decl(iteratorZip.ts, 27, 5)) +>a17 : Symbol(a17, Decl(a.ts, 27, 5)) >Iterator.zip(a16, { mode: "longest", padding: [] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->a16 : Symbol(a16, Decl(iteratorZip.ts, 26, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 27, 57)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 27, 74)) +>a16 : Symbol(a16, Decl(a.ts, 26, 13)) +>mode : Symbol(mode, Decl(a.ts, 27, 57)) +>padding : Symbol(padding, Decl(a.ts, 27, 74)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a18: { a: number; b: string; [a1]: boolean; }[] = Iterator.zipKeyed({ ->a18 : Symbol(a18, Decl(iteratorZip.ts, 29, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 29, 12)) ->b : Symbol(b, Decl(iteratorZip.ts, 29, 23)) ->[a1] : Symbol([a1], Decl(iteratorZip.ts, 29, 34)) ->a1 : Symbol(a1, Decl(iteratorZip.ts, 0, 13)) +>a18 : Symbol(a18, Decl(a.ts, 29, 5)) +>a : Symbol(a, Decl(a.ts, 29, 12)) +>b : Symbol(b, Decl(a.ts, 29, 23)) +>[a1] : Symbol([a1], Decl(a.ts, 29, 34)) +>a1 : Symbol(a1, Decl(a.ts, 0, 13)) >Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [a1]: [true, false],} as const).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) a: [1, 2], ->a : Symbol(a, Decl(iteratorZip.ts, 29, 75)) +>a : Symbol(a, Decl(a.ts, 29, 75)) b: new Set(["a", "b"]), ->b : Symbol(b, Decl(iteratorZip.ts, 30, 14)) +>b : Symbol(b, Decl(a.ts, 30, 14)) >Set : Symbol(Set, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) [a1]: [true, false], ->[a1] : Symbol([a1], Decl(iteratorZip.ts, 31, 27)) ->a1 : Symbol(a1, Decl(iteratorZip.ts, 0, 13)) +>[a1] : Symbol([a1], Decl(a.ts, 31, 27)) +>a1 : Symbol(a1, Decl(a.ts, 0, 13)) } as const).toArray(); >const : Symbol(const) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) a18[0].a = 2; ->a18[0].a : Symbol(a, Decl(iteratorZip.ts, 29, 12)) ->a18 : Symbol(a18, Decl(iteratorZip.ts, 29, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 29, 12)) +>a18[0].a : Symbol(a, Decl(a.ts, 29, 12)) +>a18 : Symbol(a18, Decl(a.ts, 29, 5)) +>a : Symbol(a, Decl(a.ts, 29, 12)) const a19: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { ->a19 : Symbol(a19, Decl(iteratorZip.ts, 37, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 37, 12)) ->b : Symbol(b, Decl(iteratorZip.ts, 37, 23)) +>a19 : Symbol(a19, Decl(a.ts, 37, 5)) +>a : Symbol(a, Decl(a.ts, 37, 12)) +>b : Symbol(b, Decl(a.ts, 37, 23)) >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 37, 60)) ->b : Symbol(b, Decl(iteratorZip.ts, 37, 68)) +>a : Symbol(a, Decl(a.ts, 37, 60)) +>b : Symbol(b, Decl(a.ts, 37, 68)) >const : Symbol(const) mode: "longest", ->mode : Symbol(mode, Decl(iteratorZip.ts, 37, 91)) +>mode : Symbol(mode, Decl(a.ts, 37, 91)) padding: { a: 1, b: "a" }, ->padding : Symbol(padding, Decl(iteratorZip.ts, 38, 20)) ->a : Symbol(a, Decl(iteratorZip.ts, 39, 14)) ->b : Symbol(b, Decl(iteratorZip.ts, 39, 20)) +>padding : Symbol(padding, Decl(a.ts, 38, 20)) +>a : Symbol(a, Decl(a.ts, 39, 14)) +>b : Symbol(b, Decl(a.ts, 39, 20)) }).toArray(); >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a20: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { ->a20 : Symbol(a20, Decl(iteratorZip.ts, 42, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 42, 12)) ->b : Symbol(b, Decl(iteratorZip.ts, 42, 35)) +>a20 : Symbol(a20, Decl(a.ts, 42, 5)) +>a : Symbol(a, Decl(a.ts, 42, 12)) +>b : Symbol(b, Decl(a.ts, 42, 35)) >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 42, 84)) ->b : Symbol(b, Decl(iteratorZip.ts, 42, 92)) +>a : Symbol(a, Decl(a.ts, 42, 84)) +>b : Symbol(b, Decl(a.ts, 42, 92)) >const : Symbol(const) mode: "longest", ->mode : Symbol(mode, Decl(iteratorZip.ts, 42, 115)) +>mode : Symbol(mode, Decl(a.ts, 42, 115)) }).toArray(); >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a21: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { ->a21 : Symbol(a21, Decl(iteratorZip.ts, 46, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 46, 12)) ->b : Symbol(b, Decl(iteratorZip.ts, 46, 35)) +>a21 : Symbol(a21, Decl(a.ts, 46, 5)) +>a : Symbol(a, Decl(a.ts, 46, 12)) +>b : Symbol(b, Decl(a.ts, 46, 35)) >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 46, 84)) ->b : Symbol(b, Decl(iteratorZip.ts, 46, 92)) +>a : Symbol(a, Decl(a.ts, 46, 84)) +>b : Symbol(b, Decl(a.ts, 46, 92)) >const : Symbol(const) mode: "longest", ->mode : Symbol(mode, Decl(iteratorZip.ts, 46, 115)) +>mode : Symbol(mode, Decl(a.ts, 46, 115)) padding: { b: "a" }, ->padding : Symbol(padding, Decl(iteratorZip.ts, 47, 20)) ->b : Symbol(b, Decl(iteratorZip.ts, 48, 14)) +>padding : Symbol(padding, Decl(a.ts, 47, 20)) +>b : Symbol(b, Decl(a.ts, 48, 14)) }).toArray(); >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a22: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, a8).toArray(); ->a22 : Symbol(a22, Decl(iteratorZip.ts, 51, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 51, 12)) ->b : Symbol(b, Decl(iteratorZip.ts, 51, 35)) +>a22 : Symbol(a22, Decl(a.ts, 51, 5)) +>a : Symbol(a, Decl(a.ts, 51, 12)) +>b : Symbol(b, Decl(a.ts, 51, 35)) >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, a8).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 51, 84)) ->b : Symbol(b, Decl(iteratorZip.ts, 51, 92)) +>a : Symbol(a, Decl(a.ts, 51, 84)) +>b : Symbol(b, Decl(a.ts, 51, 92)) >const : Symbol(const) ->a8 : Symbol(a8, Decl(iteratorZip.ts, 15, 13)) +>a8 : Symbol(a8, Decl(a.ts, 15, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) interface I1 { ->I1 : Symbol(I1, Decl(iteratorZip.ts, 51, 128)) +>I1 : Symbol(I1, Decl(a.ts, 51, 128)) a: Iterable; ->a : Symbol(I1.a, Decl(iteratorZip.ts, 53, 14)) +>a : Symbol(I1.a, Decl(a.ts, 53, 14)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) b: Iterator; ->b : Symbol(I1.b, Decl(iteratorZip.ts, 54, 24)) +>b : Symbol(I1.b, Decl(a.ts, 54, 24)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) } declare const a23: I1; ->a23 : Symbol(a23, Decl(iteratorZip.ts, 58, 13)) ->I1 : Symbol(I1, Decl(iteratorZip.ts, 51, 128)) +>a23 : Symbol(a23, Decl(a.ts, 58, 13)) +>I1 : Symbol(I1, Decl(a.ts, 51, 128)) const a24: { a: number; b: string; }[] = Iterator.zipKeyed(a23).toArray(); ->a24 : Symbol(a24, Decl(iteratorZip.ts, 59, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 59, 12)) ->b : Symbol(b, Decl(iteratorZip.ts, 59, 23)) +>a24 : Symbol(a24, Decl(a.ts, 59, 5)) +>a : Symbol(a, Decl(a.ts, 59, 12)) +>b : Symbol(b, Decl(a.ts, 59, 23)) >Iterator.zipKeyed(a23).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a23 : Symbol(a23, Decl(iteratorZip.ts, 58, 13)) +>a23 : Symbol(a23, Decl(a.ts, 58, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) Iterator.zip([[1]], { mode: "invalid" }); >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 61, 21)) - -Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }); ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->const : Symbol(const) ->mode : Symbol(mode, Decl(iteratorZip.ts, 63, 37)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 63, 54)) +>mode : Symbol(mode, Decl(a.ts, 61, 21)) Iterator.zip([[1]], { mode: "shortest", padding: [1] }); >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 65, 21)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 65, 39)) +>mode : Symbol(mode, Decl(a.ts, 63, 21)) +>padding : Symbol(padding, Decl(a.ts, 63, 39)) Iterator.zip(0); >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) @@ -321,10 +313,10 @@ Iterator.zipKeyed({ a: 0 }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 69, 19)) +>a : Symbol(a, Decl(a.ts, 67, 19)) const a25: Record[] = Iterator.zipKeyed({}).toArray(); ->a25 : Symbol(a25, Decl(iteratorZip.ts, 71, 5)) +>a25 : Symbol(a25, Decl(a.ts, 69, 5)) >Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) >PropertyKey : Symbol(PropertyKey, Decl(lib.es5.d.ts, --, --)) >Iterator.zipKeyed({}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) @@ -334,33 +326,33 @@ const a25: Record[] = Iterator.zipKeyed({}).toArray(); >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a26: Record[] = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); ->a26 : Symbol(a26, Decl(iteratorZip.ts, 72, 5)) +>a26 : Symbol(a26, Decl(a.ts, 70, 5)) >Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) >PropertyKey : Symbol(PropertyKey, Decl(lib.es5.d.ts, --, --)) >Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 72, 67)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 72, 84)) +>mode : Symbol(mode, Decl(a.ts, 70, 67)) +>padding : Symbol(padding, Decl(a.ts, 70, 84)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) declare const a27: { a: Iterable; } | { b: Iterator; }; ->a27 : Symbol(a27, Decl(iteratorZip.ts, 74, 13)) ->a : Symbol(a, Decl(iteratorZip.ts, 74, 20)) +>a27 : Symbol(a27, Decl(a.ts, 72, 13)) +>a : Symbol(a, Decl(a.ts, 72, 20)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->b : Symbol(b, Decl(iteratorZip.ts, 74, 47)) +>b : Symbol(b, Decl(a.ts, 72, 47)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) const a28: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(a27).toArray(); ->a28 : Symbol(a28, Decl(iteratorZip.ts, 75, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 75, 13)) ->b : Symbol(b, Decl(iteratorZip.ts, 75, 30)) +>a28 : Symbol(a28, Decl(a.ts, 73, 5)) +>a : Symbol(a, Decl(a.ts, 73, 13)) +>b : Symbol(b, Decl(a.ts, 73, 30)) >Iterator.zipKeyed(a27).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a27 : Symbol(a27, Decl(iteratorZip.ts, 74, 13)) +>a27 : Symbol(a27, Decl(a.ts, 72, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) Iterator.zip("ab"); @@ -388,31 +380,31 @@ Iterator.zipKeyed({ a: "ab" }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 81, 19)) +>a : Symbol(a, Decl(a.ts, 79, 19)) Iterator.zip([], { mode: "longest", padding: "ab" }); >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 82, 18)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 82, 35)) +>mode : Symbol(mode, Decl(a.ts, 80, 18)) +>padding : Symbol(padding, Decl(a.ts, 80, 35)) Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 83, 23)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 83, 40)) +>mode : Symbol(mode, Decl(a.ts, 81, 23)) +>padding : Symbol(padding, Decl(a.ts, 81, 40)) Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 84, 23)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 84, 40)) +>mode : Symbol(mode, Decl(a.ts, 82, 23)) +>padding : Symbol(padding, Decl(a.ts, 82, 40)) const a29: [string][] = Iterator.zip([new String("ab")]).toArray(); ->a29 : Symbol(a29, Decl(iteratorZip.ts, 86, 5)) +>a29 : Symbol(a29, Decl(a.ts, 84, 5)) >Iterator.zip([new String("ab")]).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) @@ -421,252 +413,252 @@ const a29: [string][] = Iterator.zip([new String("ab")]).toArray(); >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a30: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); ->a30 : Symbol(a30, Decl(iteratorZip.ts, 87, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 87, 12)) +>a30 : Symbol(a30, Decl(a.ts, 85, 5)) +>a : Symbol(a, Decl(a.ts, 85, 12)) >Iterator.zipKeyed({ a: new String("ab") }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 87, 49)) +>a : Symbol(a, Decl(a.ts, 85, 49)) >String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a31: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); ->a31 : Symbol(a31, Decl(iteratorZip.ts, 88, 5)) +>a31 : Symbol(a31, Decl(a.ts, 86, 5)) >Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 88, 61)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 88, 78)) +>mode : Symbol(mode, Decl(a.ts, 86, 61)) +>padding : Symbol(padding, Decl(a.ts, 86, 78)) >String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a32 = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); ->a32 : Symbol(a32, Decl(iteratorZip.ts, 90, 5)) +>a32 : Symbol(a32, Decl(a.ts, 88, 5)) >Iterator.zipKeyed({ a: [1], b: undefined }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 90, 31)) ->b : Symbol(b, Decl(iteratorZip.ts, 90, 39)) +>a : Symbol(a, Decl(a.ts, 88, 31)) +>b : Symbol(b, Decl(a.ts, 88, 39)) >undefined : Symbol(undefined) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a33: { a: number; }[] = a32; ->a33 : Symbol(a33, Decl(iteratorZip.ts, 91, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 91, 12)) ->a32 : Symbol(a32, Decl(iteratorZip.ts, 90, 5)) +>a33 : Symbol(a33, Decl(a.ts, 89, 5)) +>a : Symbol(a, Decl(a.ts, 89, 12)) +>a32 : Symbol(a32, Decl(a.ts, 88, 5)) a32[0].b; ->a32 : Symbol(a32, Decl(iteratorZip.ts, 90, 5)) +>a32 : Symbol(a32, Decl(a.ts, 88, 5)) const a34: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); ->a34 : Symbol(a34, Decl(iteratorZip.ts, 93, 5)) +>a34 : Symbol(a34, Decl(a.ts, 91, 5)) >Iterator.zipKeyed({ a: undefined }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 93, 40)) +>a : Symbol(a, Decl(a.ts, 91, 40)) >undefined : Symbol(undefined) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a35: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); ->a35 : Symbol(a35, Decl(iteratorZip.ts, 94, 5)) +>a35 : Symbol(a35, Decl(a.ts, 92, 5)) >Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 94, 40)) +>a : Symbol(a, Decl(a.ts, 92, 40)) >undefined : Symbol(undefined) ->mode : Symbol(mode, Decl(iteratorZip.ts, 94, 58)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 94, 75)) +>mode : Symbol(mode, Decl(a.ts, 92, 58)) +>padding : Symbol(padding, Decl(a.ts, 92, 75)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) interface I2 { ->I2 : Symbol(I2, Decl(iteratorZip.ts, 94, 101)) +>I2 : Symbol(I2, Decl(a.ts, 92, 101)) readonly a: Iterable; ->a : Symbol(I2.a, Decl(iteratorZip.ts, 96, 14)) +>a : Symbol(I2.a, Decl(a.ts, 94, 14)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) readonly b?: Iterator; ->b : Symbol(I2.b, Decl(iteratorZip.ts, 97, 33)) +>b : Symbol(I2.b, Decl(a.ts, 95, 33)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) readonly c: Iterable | undefined; ->c : Symbol(I2.c, Decl(iteratorZip.ts, 98, 34)) +>c : Symbol(I2.c, Decl(a.ts, 96, 34)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) readonly d?: undefined; ->d : Symbol(I2.d, Decl(iteratorZip.ts, 99, 46)) +>d : Symbol(I2.d, Decl(a.ts, 97, 46)) } declare const a36: I2; ->a36 : Symbol(a36, Decl(iteratorZip.ts, 102, 13)) ->I2 : Symbol(I2, Decl(iteratorZip.ts, 94, 101)) +>a36 : Symbol(a36, Decl(a.ts, 100, 13)) +>I2 : Symbol(I2, Decl(a.ts, 92, 101)) const a37 = Iterator.zipKeyed(a36).toArray(); ->a37 : Symbol(a37, Decl(iteratorZip.ts, 103, 5)) +>a37 : Symbol(a37, Decl(a.ts, 101, 5)) >Iterator.zipKeyed(a36).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a36 : Symbol(a36, Decl(iteratorZip.ts, 102, 13)) +>a36 : Symbol(a36, Decl(a.ts, 100, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a38: { a: number; b?: string; c?: boolean; }[] = a37; ->a38 : Symbol(a38, Decl(iteratorZip.ts, 104, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 104, 12)) ->b : Symbol(b, Decl(iteratorZip.ts, 104, 23)) ->c : Symbol(c, Decl(iteratorZip.ts, 104, 35)) ->a37 : Symbol(a37, Decl(iteratorZip.ts, 103, 5)) +>a38 : Symbol(a38, Decl(a.ts, 102, 5)) +>a : Symbol(a, Decl(a.ts, 102, 12)) +>b : Symbol(b, Decl(a.ts, 102, 23)) +>c : Symbol(c, Decl(a.ts, 102, 35)) +>a37 : Symbol(a37, Decl(a.ts, 101, 5)) a37[0].a = 2; ->a37[0].a : Symbol(a, Decl(iteratorZip.ts, 96, 14)) ->a37 : Symbol(a37, Decl(iteratorZip.ts, 103, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 96, 14)) +>a37[0].a : Symbol(a, Decl(a.ts, 94, 14)) +>a37 : Symbol(a37, Decl(a.ts, 101, 5)) +>a : Symbol(a, Decl(a.ts, 94, 14)) a37[0].b = "a"; ->a37[0].b : Symbol(b, Decl(iteratorZip.ts, 97, 33)) ->a37 : Symbol(a37, Decl(iteratorZip.ts, 103, 5)) ->b : Symbol(b, Decl(iteratorZip.ts, 97, 33)) +>a37[0].b : Symbol(b, Decl(a.ts, 95, 33)) +>a37 : Symbol(a37, Decl(a.ts, 101, 5)) +>b : Symbol(b, Decl(a.ts, 95, 33)) a37[0].c = true; ->a37[0].c : Symbol(c, Decl(iteratorZip.ts, 98, 34)) ->a37 : Symbol(a37, Decl(iteratorZip.ts, 103, 5)) ->c : Symbol(c, Decl(iteratorZip.ts, 98, 34)) +>a37[0].c : Symbol(c, Decl(a.ts, 96, 34)) +>a37 : Symbol(a37, Decl(a.ts, 101, 5)) +>c : Symbol(c, Decl(a.ts, 96, 34)) a37[0].d; ->a37 : Symbol(a37, Decl(iteratorZip.ts, 103, 5)) +>a37 : Symbol(a37, Decl(a.ts, 101, 5)) const a39: { a: number; c: boolean; }[] = a37; ->a39 : Symbol(a39, Decl(iteratorZip.ts, 109, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 109, 12)) ->c : Symbol(c, Decl(iteratorZip.ts, 109, 23)) ->a37 : Symbol(a37, Decl(iteratorZip.ts, 103, 5)) +>a39 : Symbol(a39, Decl(a.ts, 107, 5)) +>a : Symbol(a, Decl(a.ts, 107, 12)) +>c : Symbol(c, Decl(a.ts, 107, 23)) +>a37 : Symbol(a37, Decl(a.ts, 101, 5)) const a40: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(a36, { mode: "longest" }).toArray(); ->a40 : Symbol(a40, Decl(iteratorZip.ts, 110, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 110, 12)) ->b : Symbol(b, Decl(iteratorZip.ts, 110, 35)) ->c : Symbol(c, Decl(iteratorZip.ts, 110, 59)) +>a40 : Symbol(a40, Decl(a.ts, 108, 5)) +>a : Symbol(a, Decl(a.ts, 108, 12)) +>b : Symbol(b, Decl(a.ts, 108, 35)) +>c : Symbol(c, Decl(a.ts, 108, 59)) >Iterator.zipKeyed(a36, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a36 : Symbol(a36, Decl(iteratorZip.ts, 102, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 110, 115)) +>a36 : Symbol(a36, Decl(a.ts, 100, 13)) +>mode : Symbol(mode, Decl(a.ts, 108, 115)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) declare const a41: { a: Iterable; } | { b: Iterator; }; ->a41 : Symbol(a41, Decl(iteratorZip.ts, 112, 13)) ->a : Symbol(a, Decl(iteratorZip.ts, 112, 20)) +>a41 : Symbol(a41, Decl(a.ts, 110, 13)) +>a : Symbol(a, Decl(a.ts, 110, 20)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->b : Symbol(b, Decl(iteratorZip.ts, 112, 47)) +>b : Symbol(b, Decl(a.ts, 110, 47)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) const a42: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(a41).toArray(); ->a42 : Symbol(a42, Decl(iteratorZip.ts, 113, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 113, 13)) ->b : Symbol(b, Decl(iteratorZip.ts, 113, 30)) +>a42 : Symbol(a42, Decl(a.ts, 111, 5)) +>a : Symbol(a, Decl(a.ts, 111, 13)) +>b : Symbol(b, Decl(a.ts, 111, 30)) >Iterator.zipKeyed(a41).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a41 : Symbol(a41, Decl(iteratorZip.ts, 112, 13)) +>a41 : Symbol(a41, Decl(a.ts, 110, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) declare const a43: { a: Iterable; } | { b: number; }; ->a43 : Symbol(a43, Decl(iteratorZip.ts, 114, 13)) ->a : Symbol(a, Decl(iteratorZip.ts, 114, 20)) +>a43 : Symbol(a43, Decl(a.ts, 112, 13)) +>a : Symbol(a, Decl(a.ts, 112, 20)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->b : Symbol(b, Decl(iteratorZip.ts, 114, 47)) +>b : Symbol(b, Decl(a.ts, 112, 47)) Iterator.zipKeyed(a43); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a43 : Symbol(a43, Decl(iteratorZip.ts, 114, 13)) +>a43 : Symbol(a43, Decl(a.ts, 112, 13)) Iterator.zipKeyed(a43, { mode: "longest" }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a43 : Symbol(a43, Decl(iteratorZip.ts, 114, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 116, 24)) +>a43 : Symbol(a43, Decl(a.ts, 112, 13)) +>mode : Symbol(mode, Decl(a.ts, 114, 24)) Iterator.zipKeyed(a43, { mode: "longest", padding: {} }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a43 : Symbol(a43, Decl(iteratorZip.ts, 114, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 117, 24)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 117, 41)) +>a43 : Symbol(a43, Decl(a.ts, 112, 13)) +>mode : Symbol(mode, Decl(a.ts, 115, 24)) +>padding : Symbol(padding, Decl(a.ts, 115, 41)) declare const a44: { a?: Iterable; } | { b: string; }; ->a44 : Symbol(a44, Decl(iteratorZip.ts, 118, 13)) ->a : Symbol(a, Decl(iteratorZip.ts, 118, 20)) +>a44 : Symbol(a44, Decl(a.ts, 116, 13)) +>a : Symbol(a, Decl(a.ts, 116, 20)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->b : Symbol(b, Decl(iteratorZip.ts, 118, 48)) +>b : Symbol(b, Decl(a.ts, 116, 48)) Iterator.zipKeyed(a44); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a44 : Symbol(a44, Decl(iteratorZip.ts, 118, 13)) +>a44 : Symbol(a44, Decl(a.ts, 116, 13)) declare const a45: { a: Iterable; } | { b: undefined; }; ->a45 : Symbol(a45, Decl(iteratorZip.ts, 120, 13)) ->a : Symbol(a, Decl(iteratorZip.ts, 120, 20)) +>a45 : Symbol(a45, Decl(a.ts, 118, 13)) +>a : Symbol(a, Decl(a.ts, 118, 20)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->b : Symbol(b, Decl(iteratorZip.ts, 120, 47)) +>b : Symbol(b, Decl(a.ts, 118, 47)) const a46: { a: number; }[] = Iterator.zipKeyed(a45).toArray(); ->a46 : Symbol(a46, Decl(iteratorZip.ts, 121, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 121, 12)) +>a46 : Symbol(a46, Decl(a.ts, 119, 5)) +>a : Symbol(a, Decl(a.ts, 119, 12)) >Iterator.zipKeyed(a45).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a45 : Symbol(a45, Decl(iteratorZip.ts, 120, 13)) +>a45 : Symbol(a45, Decl(a.ts, 118, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) declare const a47: unique symbol; ->a47 : Symbol(a47, Decl(iteratorZip.ts, 123, 13)) +>a47 : Symbol(a47, Decl(a.ts, 121, 13)) declare const a48: { a: Iterable; [a47]?: Iterable; }; ->a48 : Symbol(a48, Decl(iteratorZip.ts, 124, 13)) ->a : Symbol(a, Decl(iteratorZip.ts, 124, 20)) +>a48 : Symbol(a48, Decl(a.ts, 122, 13)) +>a : Symbol(a, Decl(a.ts, 122, 20)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->[a47] : Symbol([a47], Decl(iteratorZip.ts, 124, 41)) ->a47 : Symbol(a47, Decl(iteratorZip.ts, 123, 13)) +>[a47] : Symbol([a47], Decl(a.ts, 122, 41)) +>a47 : Symbol(a47, Decl(a.ts, 121, 13)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) const a49: { a: number; [a47]?: string; }[] = Iterator.zipKeyed(a48).toArray(); ->a49 : Symbol(a49, Decl(iteratorZip.ts, 125, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 125, 12)) ->[a47] : Symbol([a47], Decl(iteratorZip.ts, 125, 23)) ->a47 : Symbol(a47, Decl(iteratorZip.ts, 123, 13)) +>a49 : Symbol(a49, Decl(a.ts, 123, 5)) +>a : Symbol(a, Decl(a.ts, 123, 12)) +>[a47] : Symbol([a47], Decl(a.ts, 123, 23)) +>a47 : Symbol(a47, Decl(a.ts, 121, 13)) >Iterator.zipKeyed(a48).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a48 : Symbol(a48, Decl(iteratorZip.ts, 124, 13)) +>a48 : Symbol(a48, Decl(a.ts, 122, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) Iterator.zipKeyed({ a: [1], b: null }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 127, 19)) ->b : Symbol(b, Decl(iteratorZip.ts, 127, 27)) +>a : Symbol(a, Decl(a.ts, 125, 19)) +>b : Symbol(b, Decl(a.ts, 125, 27)) Iterator.zipKeyed({ a: [1], b: false }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 128, 19)) ->b : Symbol(b, Decl(iteratorZip.ts, 128, 27)) +>a : Symbol(a, Decl(a.ts, 126, 19)) +>b : Symbol(b, Decl(a.ts, 126, 27)) Iterator.zip([undefined]); >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) @@ -675,585 +667,585 @@ Iterator.zip([undefined]); >undefined : Symbol(undefined) declare const a50: { a?: undefined; }; ->a50 : Symbol(a50, Decl(iteratorZip.ts, 131, 13)) ->a : Symbol(a, Decl(iteratorZip.ts, 131, 20)) +>a50 : Symbol(a50, Decl(a.ts, 129, 13)) +>a : Symbol(a, Decl(a.ts, 129, 20)) const a51: never[] = Iterator.zipKeyed(a50).toArray(); ->a51 : Symbol(a51, Decl(iteratorZip.ts, 132, 5)) +>a51 : Symbol(a51, Decl(a.ts, 130, 5)) >Iterator.zipKeyed(a50).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a50 : Symbol(a50, Decl(iteratorZip.ts, 131, 13)) +>a50 : Symbol(a50, Decl(a.ts, 129, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a52: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); ->a52 : Symbol(a52, Decl(iteratorZip.ts, 133, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 133, 12)) +>a52 : Symbol(a52, Decl(a.ts, 131, 5)) +>a : Symbol(a, Decl(a.ts, 131, 12)) >Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 133, 49)) ->b : Symbol(b, Decl(iteratorZip.ts, 133, 57)) +>a : Symbol(a, Decl(a.ts, 131, 49)) +>b : Symbol(b, Decl(a.ts, 131, 57)) >undefined : Symbol(undefined) ->mode : Symbol(mode, Decl(iteratorZip.ts, 133, 75)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 133, 92)) ->a : Symbol(a, Decl(iteratorZip.ts, 133, 103)) +>mode : Symbol(mode, Decl(a.ts, 131, 75)) +>padding : Symbol(padding, Decl(a.ts, 131, 92)) +>a : Symbol(a, Decl(a.ts, 131, 103)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a53: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); ->a53 : Symbol(a53, Decl(iteratorZip.ts, 134, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 134, 12)) +>a53 : Symbol(a53, Decl(a.ts, 132, 5)) +>a : Symbol(a, Decl(a.ts, 132, 12)) >Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 134, 61)) ->b : Symbol(b, Decl(iteratorZip.ts, 134, 69)) +>a : Symbol(a, Decl(a.ts, 132, 61)) +>b : Symbol(b, Decl(a.ts, 132, 69)) >undefined : Symbol(undefined) ->mode : Symbol(mode, Decl(iteratorZip.ts, 134, 87)) +>mode : Symbol(mode, Decl(a.ts, 132, 87)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) function f1(a: Iterable) { ->f1 : Symbol(f1, Decl(iteratorZip.ts, 134, 117)) ->T : Symbol(T, Decl(iteratorZip.ts, 136, 12)) ->a : Symbol(a, Decl(iteratorZip.ts, 136, 15)) +>f1 : Symbol(f1, Decl(a.ts, 132, 117)) +>T : Symbol(T, Decl(a.ts, 134, 12)) +>a : Symbol(a, Decl(a.ts, 134, 15)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->T : Symbol(T, Decl(iteratorZip.ts, 136, 12)) +>T : Symbol(T, Decl(a.ts, 134, 12)) const b: { a: T; }[] = Iterator.zipKeyed({ a }).toArray(); ->b : Symbol(b, Decl(iteratorZip.ts, 137, 9)) ->a : Symbol(a, Decl(iteratorZip.ts, 137, 14)) ->T : Symbol(T, Decl(iteratorZip.ts, 136, 12)) +>b : Symbol(b, Decl(a.ts, 135, 9)) +>a : Symbol(a, Decl(a.ts, 135, 14)) +>T : Symbol(T, Decl(a.ts, 134, 12)) >Iterator.zipKeyed({ a }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 137, 46)) +>a : Symbol(a, Decl(a.ts, 135, 46)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const c: [T][] = Iterator.zip([a]).toArray(); ->c : Symbol(c, Decl(iteratorZip.ts, 138, 9)) ->T : Symbol(T, Decl(iteratorZip.ts, 136, 12)) +>c : Symbol(c, Decl(a.ts, 136, 9)) +>T : Symbol(T, Decl(a.ts, 134, 12)) >Iterator.zip([a]).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->a : Symbol(a, Decl(iteratorZip.ts, 136, 15)) +>a : Symbol(a, Decl(a.ts, 134, 15)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) return { b, c }; ->b : Symbol(b, Decl(iteratorZip.ts, 139, 12)) ->c : Symbol(c, Decl(iteratorZip.ts, 139, 15)) +>b : Symbol(b, Decl(a.ts, 137, 12)) +>c : Symbol(c, Decl(a.ts, 137, 15)) } const a54: [Iterable, ...Iterable[]] = [[1, 2], [3]]; ->a54 : Symbol(a54, Decl(iteratorZip.ts, 142, 5)) +>a54 : Symbol(a54, Decl(a.ts, 140, 5)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) const a55 = Iterator.zip(a54, { mode: "longest", padding: [0] }).toArray(); ->a55 : Symbol(a55, Decl(iteratorZip.ts, 143, 5)) +>a55 : Symbol(a55, Decl(a.ts, 141, 5)) >Iterator.zip(a54, { mode: "longest", padding: [0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->a54 : Symbol(a54, Decl(iteratorZip.ts, 142, 5)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 143, 31)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 143, 48)) +>a54 : Symbol(a54, Decl(a.ts, 140, 5)) +>mode : Symbol(mode, Decl(a.ts, 141, 31)) +>padding : Symbol(padding, Decl(a.ts, 141, 48)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a56: (number | undefined)[][] = a55; ->a56 : Symbol(a56, Decl(iteratorZip.ts, 144, 5)) ->a55 : Symbol(a55, Decl(iteratorZip.ts, 143, 5)) +>a56 : Symbol(a56, Decl(a.ts, 142, 5)) +>a55 : Symbol(a55, Decl(a.ts, 141, 5)) const a57: number[][] = a55; ->a57 : Symbol(a57, Decl(iteratorZip.ts, 145, 5)) ->a55 : Symbol(a55, Decl(iteratorZip.ts, 143, 5)) +>a57 : Symbol(a57, Decl(a.ts, 143, 5)) +>a55 : Symbol(a55, Decl(a.ts, 141, 5)) const a58: Record> = { a: [1], b: [2, 3] }; ->a58 : Symbol(a58, Decl(iteratorZip.ts, 147, 5)) +>a58 : Symbol(a58, Decl(a.ts, 145, 5)) >Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 147, 47)) ->b : Symbol(b, Decl(iteratorZip.ts, 147, 55)) +>a : Symbol(a, Decl(a.ts, 145, 47)) +>b : Symbol(b, Decl(a.ts, 145, 55)) const a59 = Iterator.zipKeyed(a58, { mode: "longest", padding: {} }).toArray(); ->a59 : Symbol(a59, Decl(iteratorZip.ts, 148, 5)) +>a59 : Symbol(a59, Decl(a.ts, 146, 5)) >Iterator.zipKeyed(a58, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a58 : Symbol(a58, Decl(iteratorZip.ts, 147, 5)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 148, 36)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 148, 53)) +>a58 : Symbol(a58, Decl(a.ts, 145, 5)) +>mode : Symbol(mode, Decl(a.ts, 146, 36)) +>padding : Symbol(padding, Decl(a.ts, 146, 53)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a60: Record[] = a59; ->a60 : Symbol(a60, Decl(iteratorZip.ts, 149, 5)) +>a60 : Symbol(a60, Decl(a.ts, 147, 5)) >Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) ->a59 : Symbol(a59, Decl(iteratorZip.ts, 148, 5)) +>a59 : Symbol(a59, Decl(a.ts, 146, 5)) const a61: Record[] = a59; ->a61 : Symbol(a61, Decl(iteratorZip.ts, 150, 5)) +>a61 : Symbol(a61, Decl(a.ts, 148, 5)) >Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) ->a59 : Symbol(a59, Decl(iteratorZip.ts, 148, 5)) +>a59 : Symbol(a59, Decl(a.ts, 146, 5)) declare const a62: Record; ->a62 : Symbol(a62, Decl(iteratorZip.ts, 152, 13)) +>a62 : Symbol(a62, Decl(a.ts, 150, 13)) >Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) const a63 = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a62 }).toArray(); ->a63 : Symbol(a63, Decl(iteratorZip.ts, 153, 5)) +>a63 : Symbol(a63, Decl(a.ts, 151, 5)) >Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a62 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 153, 31)) ->b : Symbol(b, Decl(iteratorZip.ts, 153, 39)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 153, 54)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 153, 71)) ->a62 : Symbol(a62, Decl(iteratorZip.ts, 152, 13)) +>a : Symbol(a, Decl(a.ts, 151, 31)) +>b : Symbol(b, Decl(a.ts, 151, 39)) +>mode : Symbol(mode, Decl(a.ts, 151, 54)) +>padding : Symbol(padding, Decl(a.ts, 151, 71)) +>a62 : Symbol(a62, Decl(a.ts, 150, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a64: { a: number | undefined; b: number | undefined; }[] = a63; ->a64 : Symbol(a64, Decl(iteratorZip.ts, 154, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 154, 12)) ->b : Symbol(b, Decl(iteratorZip.ts, 154, 35)) ->a63 : Symbol(a63, Decl(iteratorZip.ts, 153, 5)) +>a64 : Symbol(a64, Decl(a.ts, 152, 5)) +>a : Symbol(a, Decl(a.ts, 152, 12)) +>b : Symbol(b, Decl(a.ts, 152, 35)) +>a63 : Symbol(a63, Decl(a.ts, 151, 5)) const a65: { a: number; b: number; }[] = a63; ->a65 : Symbol(a65, Decl(iteratorZip.ts, 155, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 155, 12)) ->b : Symbol(b, Decl(iteratorZip.ts, 155, 23)) ->a63 : Symbol(a63, Decl(iteratorZip.ts, 153, 5)) +>a65 : Symbol(a65, Decl(a.ts, 153, 5)) +>a : Symbol(a, Decl(a.ts, 153, 12)) +>b : Symbol(b, Decl(a.ts, 153, 23)) +>a63 : Symbol(a63, Decl(a.ts, 151, 5)) const a66 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); ->a66 : Symbol(a66, Decl(iteratorZip.ts, 157, 5)) +>a66 : Symbol(a66, Decl(a.ts, 155, 5)) >Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 157, 40)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 157, 57)) +>mode : Symbol(mode, Decl(a.ts, 155, 40)) +>padding : Symbol(padding, Decl(a.ts, 155, 57)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a67: [number, string][] = a66; ->a67 : Symbol(a67, Decl(iteratorZip.ts, 158, 5)) ->a66 : Symbol(a66, Decl(iteratorZip.ts, 157, 5)) +>a67 : Symbol(a67, Decl(a.ts, 156, 5)) +>a66 : Symbol(a66, Decl(a.ts, 155, 5)) const a68 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); ->a68 : Symbol(a68, Decl(iteratorZip.ts, 159, 5)) +>a68 : Symbol(a68, Decl(a.ts, 157, 5)) >Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 159, 31)) ->b : Symbol(b, Decl(iteratorZip.ts, 159, 39)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 159, 53)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 159, 70)) ->a : Symbol(a, Decl(iteratorZip.ts, 159, 81)) ->b : Symbol(b, Decl(iteratorZip.ts, 159, 87)) +>a : Symbol(a, Decl(a.ts, 157, 31)) +>b : Symbol(b, Decl(a.ts, 157, 39)) +>mode : Symbol(mode, Decl(a.ts, 157, 53)) +>padding : Symbol(padding, Decl(a.ts, 157, 70)) +>a : Symbol(a, Decl(a.ts, 157, 81)) +>b : Symbol(b, Decl(a.ts, 157, 87)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a69: { a: number; b: string; }[] = a68; ->a69 : Symbol(a69, Decl(iteratorZip.ts, 160, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 160, 12)) ->b : Symbol(b, Decl(iteratorZip.ts, 160, 23)) ->a68 : Symbol(a68, Decl(iteratorZip.ts, 159, 5)) +>a69 : Symbol(a69, Decl(a.ts, 158, 5)) +>a : Symbol(a, Decl(a.ts, 158, 12)) +>b : Symbol(b, Decl(a.ts, 158, 23)) +>a68 : Symbol(a68, Decl(a.ts, 157, 5)) const a70 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); ->a70 : Symbol(a70, Decl(iteratorZip.ts, 162, 5)) +>a70 : Symbol(a70, Decl(a.ts, 160, 5)) >Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 162, 40)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 162, 57)) +>mode : Symbol(mode, Decl(a.ts, 160, 40)) +>padding : Symbol(padding, Decl(a.ts, 160, 57)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a71: [number | undefined, string | undefined][] = a70; ->a71 : Symbol(a71, Decl(iteratorZip.ts, 163, 5)) ->a70 : Symbol(a70, Decl(iteratorZip.ts, 162, 5)) +>a71 : Symbol(a71, Decl(a.ts, 161, 5)) +>a70 : Symbol(a70, Decl(a.ts, 160, 5)) const a72: [number, string][] = a70; ->a72 : Symbol(a72, Decl(iteratorZip.ts, 164, 5)) ->a70 : Symbol(a70, Decl(iteratorZip.ts, 162, 5)) +>a72 : Symbol(a72, Decl(a.ts, 162, 5)) +>a70 : Symbol(a70, Decl(a.ts, 160, 5)) const a73 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); ->a73 : Symbol(a73, Decl(iteratorZip.ts, 165, 5)) +>a73 : Symbol(a73, Decl(a.ts, 163, 5)) >Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 165, 31)) ->b : Symbol(b, Decl(iteratorZip.ts, 165, 39)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 165, 53)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 165, 70)) ->a : Symbol(a, Decl(iteratorZip.ts, 165, 81)) +>a : Symbol(a, Decl(a.ts, 163, 31)) +>b : Symbol(b, Decl(a.ts, 163, 39)) +>mode : Symbol(mode, Decl(a.ts, 163, 53)) +>padding : Symbol(padding, Decl(a.ts, 163, 70)) +>a : Symbol(a, Decl(a.ts, 163, 81)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a74: { a: number | undefined; b: string | undefined; }[] = a73; ->a74 : Symbol(a74, Decl(iteratorZip.ts, 166, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 166, 12)) ->b : Symbol(b, Decl(iteratorZip.ts, 166, 35)) ->a73 : Symbol(a73, Decl(iteratorZip.ts, 165, 5)) +>a74 : Symbol(a74, Decl(a.ts, 164, 5)) +>a : Symbol(a, Decl(a.ts, 164, 12)) +>b : Symbol(b, Decl(a.ts, 164, 35)) +>a73 : Symbol(a73, Decl(a.ts, 163, 5)) const a75: { a: number; b: string; }[] = a73; ->a75 : Symbol(a75, Decl(iteratorZip.ts, 167, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 167, 12)) ->b : Symbol(b, Decl(iteratorZip.ts, 167, 23)) ->a73 : Symbol(a73, Decl(iteratorZip.ts, 165, 5)) +>a75 : Symbol(a75, Decl(a.ts, 165, 5)) +>a : Symbol(a, Decl(a.ts, 165, 12)) +>b : Symbol(b, Decl(a.ts, 165, 23)) +>a73 : Symbol(a73, Decl(a.ts, 163, 5)) declare const a76: readonly [number, string]; ->a76 : Symbol(a76, Decl(iteratorZip.ts, 169, 13)) +>a76 : Symbol(a76, Decl(a.ts, 167, 13)) const a77: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a76 }).toArray(); ->a77 : Symbol(a77, Decl(iteratorZip.ts, 170, 5)) +>a77 : Symbol(a77, Decl(a.ts, 168, 5)) >Iterator.zip([[1], ["a"]], { mode: "longest", padding: a76 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 170, 60)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 170, 77)) ->a76 : Symbol(a76, Decl(iteratorZip.ts, 169, 13)) +>mode : Symbol(mode, Decl(a.ts, 168, 60)) +>padding : Symbol(padding, Decl(a.ts, 168, 77)) +>a76 : Symbol(a76, Decl(a.ts, 167, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) declare const a78: [number, string?]; ->a78 : Symbol(a78, Decl(iteratorZip.ts, 171, 13)) +>a78 : Symbol(a78, Decl(a.ts, 169, 13)) const a79 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a78 }).toArray(); ->a79 : Symbol(a79, Decl(iteratorZip.ts, 172, 5)) +>a79 : Symbol(a79, Decl(a.ts, 170, 5)) >Iterator.zip([[1], ["a"]], { mode: "longest", padding: a78 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 172, 40)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 172, 57)) ->a78 : Symbol(a78, Decl(iteratorZip.ts, 171, 13)) +>mode : Symbol(mode, Decl(a.ts, 170, 40)) +>padding : Symbol(padding, Decl(a.ts, 170, 57)) +>a78 : Symbol(a78, Decl(a.ts, 169, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a80: [number, string][] = a79; ->a80 : Symbol(a80, Decl(iteratorZip.ts, 173, 5)) ->a79 : Symbol(a79, Decl(iteratorZip.ts, 172, 5)) +>a80 : Symbol(a80, Decl(a.ts, 171, 5)) +>a79 : Symbol(a79, Decl(a.ts, 170, 5)) declare const a81: [Iterable] | [Iterable, Iterable]; ->a81 : Symbol(a81, Decl(iteratorZip.ts, 175, 13)) +>a81 : Symbol(a81, Decl(a.ts, 173, 13)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) const a82 = Iterator.zip(a81, { mode: "longest", padding: [0] }).toArray(); ->a82 : Symbol(a82, Decl(iteratorZip.ts, 176, 5)) +>a82 : Symbol(a82, Decl(a.ts, 174, 5)) >Iterator.zip(a81, { mode: "longest", padding: [0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->a81 : Symbol(a81, Decl(iteratorZip.ts, 175, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 176, 31)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 176, 48)) +>a81 : Symbol(a81, Decl(a.ts, 173, 13)) +>mode : Symbol(mode, Decl(a.ts, 174, 31)) +>padding : Symbol(padding, Decl(a.ts, 174, 48)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a83: number[][] = a82; ->a83 : Symbol(a83, Decl(iteratorZip.ts, 177, 5)) ->a82 : Symbol(a82, Decl(iteratorZip.ts, 176, 5)) +>a83 : Symbol(a83, Decl(a.ts, 175, 5)) +>a82 : Symbol(a82, Decl(a.ts, 174, 5)) declare const a84: { a: Iterable; } | { b: Iterable; }; ->a84 : Symbol(a84, Decl(iteratorZip.ts, 178, 13)) ->a : Symbol(a, Decl(iteratorZip.ts, 178, 20)) +>a84 : Symbol(a84, Decl(a.ts, 176, 13)) +>a : Symbol(a, Decl(a.ts, 176, 20)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->b : Symbol(b, Decl(iteratorZip.ts, 178, 47)) +>b : Symbol(b, Decl(a.ts, 176, 47)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) const a85 = Iterator.zipKeyed(a84, { mode: "longest", padding: { a: 0 } }).toArray(); ->a85 : Symbol(a85, Decl(iteratorZip.ts, 179, 5)) +>a85 : Symbol(a85, Decl(a.ts, 177, 5)) >Iterator.zipKeyed(a84, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a84 : Symbol(a84, Decl(iteratorZip.ts, 178, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 179, 36)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 179, 53)) ->a : Symbol(a, Decl(iteratorZip.ts, 179, 64)) +>a84 : Symbol(a84, Decl(a.ts, 176, 13)) +>mode : Symbol(mode, Decl(a.ts, 177, 36)) +>padding : Symbol(padding, Decl(a.ts, 177, 53)) +>a : Symbol(a, Decl(a.ts, 177, 64)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a86: ({ a: number; } | { b: string; })[] = a85; ->a86 : Symbol(a86, Decl(iteratorZip.ts, 180, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 180, 13)) ->b : Symbol(b, Decl(iteratorZip.ts, 180, 30)) ->a85 : Symbol(a85, Decl(iteratorZip.ts, 179, 5)) +>a86 : Symbol(a86, Decl(a.ts, 178, 5)) +>a : Symbol(a, Decl(a.ts, 178, 13)) +>b : Symbol(b, Decl(a.ts, 178, 30)) +>a85 : Symbol(a85, Decl(a.ts, 177, 5)) declare const a87: { a: number; } | { b: string; }; ->a87 : Symbol(a87, Decl(iteratorZip.ts, 182, 13)) ->a : Symbol(a, Decl(iteratorZip.ts, 182, 20)) ->b : Symbol(b, Decl(iteratorZip.ts, 182, 37)) +>a87 : Symbol(a87, Decl(a.ts, 180, 13)) +>a : Symbol(a, Decl(a.ts, 180, 20)) +>b : Symbol(b, Decl(a.ts, 180, 37)) const a88 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: a87 }).toArray(); ->a88 : Symbol(a88, Decl(iteratorZip.ts, 183, 5)) +>a88 : Symbol(a88, Decl(a.ts, 181, 5)) >Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: a87 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 183, 31)) ->b : Symbol(b, Decl(iteratorZip.ts, 183, 39)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 183, 53)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 183, 70)) ->a87 : Symbol(a87, Decl(iteratorZip.ts, 182, 13)) +>a : Symbol(a, Decl(a.ts, 181, 31)) +>b : Symbol(b, Decl(a.ts, 181, 39)) +>mode : Symbol(mode, Decl(a.ts, 181, 53)) +>padding : Symbol(padding, Decl(a.ts, 181, 70)) +>a87 : Symbol(a87, Decl(a.ts, 180, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a89: { a: number; b: string; }[] = a88; ->a89 : Symbol(a89, Decl(iteratorZip.ts, 184, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 184, 12)) ->b : Symbol(b, Decl(iteratorZip.ts, 184, 23)) ->a88 : Symbol(a88, Decl(iteratorZip.ts, 183, 5)) +>a89 : Symbol(a89, Decl(a.ts, 182, 5)) +>a : Symbol(a, Decl(a.ts, 182, 12)) +>b : Symbol(b, Decl(a.ts, 182, 23)) +>a88 : Symbol(a88, Decl(a.ts, 181, 5)) const a90 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); ->a90 : Symbol(a90, Decl(iteratorZip.ts, 186, 5)) +>a90 : Symbol(a90, Decl(a.ts, 184, 5)) >Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 186, 31)) ->b : Symbol(b, Decl(iteratorZip.ts, 186, 39)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 186, 51)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 186, 68)) ->a : Symbol(a, Decl(iteratorZip.ts, 186, 79)) +>a : Symbol(a, Decl(a.ts, 184, 31)) +>b : Symbol(b, Decl(a.ts, 184, 39)) +>mode : Symbol(mode, Decl(a.ts, 184, 51)) +>padding : Symbol(padding, Decl(a.ts, 184, 68)) +>a : Symbol(a, Decl(a.ts, 184, 79)) >undefined : Symbol(undefined) ->b : Symbol(b, Decl(iteratorZip.ts, 186, 93)) +>b : Symbol(b, Decl(a.ts, 184, 93)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a91: { a: number; b: number; }[] = a90; ->a91 : Symbol(a91, Decl(iteratorZip.ts, 187, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 187, 12)) ->b : Symbol(b, Decl(iteratorZip.ts, 187, 23)) ->a90 : Symbol(a90, Decl(iteratorZip.ts, 186, 5)) +>a91 : Symbol(a91, Decl(a.ts, 185, 5)) +>a : Symbol(a, Decl(a.ts, 185, 12)) +>b : Symbol(b, Decl(a.ts, 185, 23)) +>a90 : Symbol(a90, Decl(a.ts, 184, 5)) declare const a92: { [K in `a${string}`]: Iterable; }; ->a92 : Symbol(a92, Decl(iteratorZip.ts, 189, 13)) ->K : Symbol(K, Decl(iteratorZip.ts, 189, 22)) +>a92 : Symbol(a92, Decl(a.ts, 187, 13)) +>K : Symbol(K, Decl(a.ts, 187, 22)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) const a93 = Iterator.zipKeyed(a92, { mode: "longest", padding: {} }).toArray(); ->a93 : Symbol(a93, Decl(iteratorZip.ts, 190, 5)) +>a93 : Symbol(a93, Decl(a.ts, 188, 5)) >Iterator.zipKeyed(a92, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a92 : Symbol(a92, Decl(iteratorZip.ts, 189, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 190, 36)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 190, 53)) +>a92 : Symbol(a92, Decl(a.ts, 187, 13)) +>mode : Symbol(mode, Decl(a.ts, 188, 36)) +>padding : Symbol(padding, Decl(a.ts, 188, 53)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a94: { [K in `a${string}`]: number; }[] = a93; ->a94 : Symbol(a94, Decl(iteratorZip.ts, 191, 5)) ->K : Symbol(K, Decl(iteratorZip.ts, 191, 14)) ->a93 : Symbol(a93, Decl(iteratorZip.ts, 190, 5)) +>a94 : Symbol(a94, Decl(a.ts, 189, 5)) +>K : Symbol(K, Decl(a.ts, 189, 14)) +>a93 : Symbol(a93, Decl(a.ts, 188, 5)) declare const a95: unique symbol; ->a95 : Symbol(a95, Decl(iteratorZip.ts, 193, 13)) +>a95 : Symbol(a95, Decl(a.ts, 191, 13)) const a96: { [a95]: number; }[] = Iterator.zipKeyed({ [a95]: [1] }, { mode: "longest", padding: { [a95]: 0 } }).toArray(); ->a96 : Symbol(a96, Decl(iteratorZip.ts, 194, 5)) ->[a95] : Symbol([a95], Decl(iteratorZip.ts, 194, 12)) ->a95 : Symbol(a95, Decl(iteratorZip.ts, 193, 13)) +>a96 : Symbol(a96, Decl(a.ts, 192, 5)) +>[a95] : Symbol([a95], Decl(a.ts, 192, 12)) +>a95 : Symbol(a95, Decl(a.ts, 191, 13)) >Iterator.zipKeyed({ [a95]: [1] }, { mode: "longest", padding: { [a95]: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->[a95] : Symbol([a95], Decl(iteratorZip.ts, 194, 53)) ->a95 : Symbol(a95, Decl(iteratorZip.ts, 193, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 194, 69)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 194, 86)) ->[a95] : Symbol([a95], Decl(iteratorZip.ts, 194, 97)) ->a95 : Symbol(a95, Decl(iteratorZip.ts, 193, 13)) +>[a95] : Symbol([a95], Decl(a.ts, 192, 53)) +>a95 : Symbol(a95, Decl(a.ts, 191, 13)) +>mode : Symbol(mode, Decl(a.ts, 192, 69)) +>padding : Symbol(padding, Decl(a.ts, 192, 86)) +>[a95] : Symbol([a95], Decl(a.ts, 192, 97)) +>a95 : Symbol(a95, Decl(a.ts, 191, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) declare const a97: Record & { a: number; }; ->a97 : Symbol(a97, Decl(iteratorZip.ts, 196, 13)) +>a97 : Symbol(a97, Decl(a.ts, 194, 13)) >Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 196, 45)) +>a : Symbol(a, Decl(a.ts, 194, 45)) const a98 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: a97 }).toArray(); ->a98 : Symbol(a98, Decl(iteratorZip.ts, 197, 5)) +>a98 : Symbol(a98, Decl(a.ts, 195, 5)) >Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: a97 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 197, 31)) ->b : Symbol(b, Decl(iteratorZip.ts, 197, 39)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 197, 51)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 197, 68)) ->a97 : Symbol(a97, Decl(iteratorZip.ts, 196, 13)) +>a : Symbol(a, Decl(a.ts, 195, 31)) +>b : Symbol(b, Decl(a.ts, 195, 39)) +>mode : Symbol(mode, Decl(a.ts, 195, 51)) +>padding : Symbol(padding, Decl(a.ts, 195, 68)) +>a97 : Symbol(a97, Decl(a.ts, 194, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a99: { a: number; b: number | undefined; }[] = a98; ->a99 : Symbol(a99, Decl(iteratorZip.ts, 198, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 198, 12)) ->b : Symbol(b, Decl(iteratorZip.ts, 198, 23)) ->a98 : Symbol(a98, Decl(iteratorZip.ts, 197, 5)) +>a99 : Symbol(a99, Decl(a.ts, 196, 5)) +>a : Symbol(a, Decl(a.ts, 196, 12)) +>b : Symbol(b, Decl(a.ts, 196, 23)) +>a98 : Symbol(a98, Decl(a.ts, 195, 5)) const a100: { a: number; b: number; }[] = a98; ->a100 : Symbol(a100, Decl(iteratorZip.ts, 199, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 199, 13)) ->b : Symbol(b, Decl(iteratorZip.ts, 199, 24)) ->a98 : Symbol(a98, Decl(iteratorZip.ts, 197, 5)) +>a100 : Symbol(a100, Decl(a.ts, 197, 5)) +>a : Symbol(a, Decl(a.ts, 197, 13)) +>b : Symbol(b, Decl(a.ts, 197, 24)) +>a98 : Symbol(a98, Decl(a.ts, 195, 5)) declare const a101: [number] | [number, string]; ->a101 : Symbol(a101, Decl(iteratorZip.ts, 201, 13)) +>a101 : Symbol(a101, Decl(a.ts, 199, 13)) const a102 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a101 }).toArray(); ->a102 : Symbol(a102, Decl(iteratorZip.ts, 202, 5)) +>a102 : Symbol(a102, Decl(a.ts, 200, 5)) >Iterator.zip([[1], ["a"]], { mode: "longest", padding: a101 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 202, 41)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 202, 58)) ->a101 : Symbol(a101, Decl(iteratorZip.ts, 201, 13)) +>mode : Symbol(mode, Decl(a.ts, 200, 41)) +>padding : Symbol(padding, Decl(a.ts, 200, 58)) +>a101 : Symbol(a101, Decl(a.ts, 199, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a103: [number, string | undefined][] = a102; ->a103 : Symbol(a103, Decl(iteratorZip.ts, 203, 5)) ->a102 : Symbol(a102, Decl(iteratorZip.ts, 202, 5)) +>a103 : Symbol(a103, Decl(a.ts, 201, 5)) +>a102 : Symbol(a102, Decl(a.ts, 200, 5)) const a104: [number, string][] = a102; ->a104 : Symbol(a104, Decl(iteratorZip.ts, 204, 5)) ->a102 : Symbol(a102, Decl(iteratorZip.ts, 202, 5)) +>a104 : Symbol(a104, Decl(a.ts, 202, 5)) +>a102 : Symbol(a102, Decl(a.ts, 200, 5)) const a105: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); ->a105 : Symbol(a105, Decl(iteratorZip.ts, 206, 5)) +>a105 : Symbol(a105, Decl(a.ts, 204, 5)) >Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 206, 71)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 206, 88)) +>mode : Symbol(mode, Decl(a.ts, 204, 71)) +>padding : Symbol(padding, Decl(a.ts, 204, 88)) >undefined : Symbol(undefined) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a106: { a: number | undefined; b: number; }[] = a90; ->a106 : Symbol(a106, Decl(iteratorZip.ts, 207, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 207, 13)) ->b : Symbol(b, Decl(iteratorZip.ts, 207, 36)) ->a90 : Symbol(a90, Decl(iteratorZip.ts, 186, 5)) +>a106 : Symbol(a106, Decl(a.ts, 205, 5)) +>a : Symbol(a, Decl(a.ts, 205, 13)) +>b : Symbol(b, Decl(a.ts, 205, 36)) +>a90 : Symbol(a90, Decl(a.ts, 184, 5)) class C1 { ->C1 : Symbol(C1, Decl(iteratorZip.ts, 207, 58)) +>C1 : Symbol(C1, Decl(a.ts, 205, 58)) a = [1, 2]; ->a : Symbol(C1.a, Decl(iteratorZip.ts, 209, 10)) +>a : Symbol(C1.a, Decl(a.ts, 207, 10)) get b() { ->b : Symbol(C1.b, Decl(iteratorZip.ts, 210, 15)) +>b : Symbol(C1.b, Decl(a.ts, 208, 15)) return "inputs"; } f() { ->f : Symbol(C1.f, Decl(iteratorZip.ts, 214, 5)) +>f : Symbol(C1.f, Decl(a.ts, 212, 5)) return this.b; ->this.b : Symbol(C1.b, Decl(iteratorZip.ts, 210, 15)) ->this : Symbol(C1, Decl(iteratorZip.ts, 207, 58)) ->b : Symbol(C1.b, Decl(iteratorZip.ts, 210, 15)) +>this.b : Symbol(C1.b, Decl(a.ts, 208, 15)) +>this : Symbol(C1, Decl(a.ts, 205, 58)) +>b : Symbol(C1.b, Decl(a.ts, 208, 15)) } } const a107 = new C1(); ->a107 : Symbol(a107, Decl(iteratorZip.ts, 221, 5)) ->C1 : Symbol(C1, Decl(iteratorZip.ts, 207, 58)) +>a107 : Symbol(a107, Decl(a.ts, 219, 5)) +>C1 : Symbol(C1, Decl(a.ts, 205, 58)) const a108 = Iterator.zipKeyed(a107).toArray(); ->a108 : Symbol(a108, Decl(iteratorZip.ts, 222, 5)) +>a108 : Symbol(a108, Decl(a.ts, 220, 5)) >Iterator.zipKeyed(a107).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a107 : Symbol(a107, Decl(iteratorZip.ts, 221, 5)) +>a107 : Symbol(a107, Decl(a.ts, 219, 5)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a109 = Iterator.zipKeyed(a107, { mode: "strict" }).toArray(); ->a109 : Symbol(a109, Decl(iteratorZip.ts, 223, 5)) +>a109 : Symbol(a109, Decl(a.ts, 221, 5)) >Iterator.zipKeyed(a107, { mode: "strict" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a107 : Symbol(a107, Decl(iteratorZip.ts, 221, 5)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 223, 38)) +>a107 : Symbol(a107, Decl(a.ts, 219, 5)) +>mode : Symbol(mode, Decl(a.ts, 221, 38)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a110 = Iterator.zipKeyed(a107, { mode: "longest" }).toArray(); ->a110 : Symbol(a110, Decl(iteratorZip.ts, 224, 5)) +>a110 : Symbol(a110, Decl(a.ts, 222, 5)) >Iterator.zipKeyed(a107, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a107 : Symbol(a107, Decl(iteratorZip.ts, 221, 5)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 224, 38)) +>a107 : Symbol(a107, Decl(a.ts, 219, 5)) +>mode : Symbol(mode, Decl(a.ts, 222, 38)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a111 = Iterator.zipKeyed(a107, { mode: "longest", padding: { a: 0 } }).toArray(); ->a111 : Symbol(a111, Decl(iteratorZip.ts, 225, 5)) +>a111 : Symbol(a111, Decl(a.ts, 223, 5)) >Iterator.zipKeyed(a107, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a107 : Symbol(a107, Decl(iteratorZip.ts, 221, 5)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 225, 38)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 225, 55)) ->a : Symbol(a, Decl(iteratorZip.ts, 225, 66)) +>a107 : Symbol(a107, Decl(a.ts, 219, 5)) +>mode : Symbol(mode, Decl(a.ts, 223, 38)) +>padding : Symbol(padding, Decl(a.ts, 223, 55)) +>a : Symbol(a, Decl(a.ts, 223, 66)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a112 = { a: [1, 2], b: "inputs" }; ->a112 : Symbol(a112, Decl(iteratorZip.ts, 227, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 227, 14)) ->b : Symbol(b, Decl(iteratorZip.ts, 227, 25)) +>a112 : Symbol(a112, Decl(a.ts, 225, 5)) +>a : Symbol(a, Decl(a.ts, 225, 14)) +>b : Symbol(b, Decl(a.ts, 225, 25)) Object.defineProperty(a112, "b", { enumerable: false }); >Object.defineProperty : Symbol(ObjectConstructor.defineProperty, Decl(lib.es5.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) >defineProperty : Symbol(ObjectConstructor.defineProperty, Decl(lib.es5.d.ts, --, --)) ->a112 : Symbol(a112, Decl(iteratorZip.ts, 227, 5)) ->enumerable : Symbol(enumerable, Decl(iteratorZip.ts, 228, 34)) +>a112 : Symbol(a112, Decl(a.ts, 225, 5)) +>enumerable : Symbol(enumerable, Decl(a.ts, 226, 34)) const a113 = Iterator.zipKeyed(a112).toArray(); ->a113 : Symbol(a113, Decl(iteratorZip.ts, 229, 5)) +>a113 : Symbol(a113, Decl(a.ts, 227, 5)) >Iterator.zipKeyed(a112).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a112 : Symbol(a112, Decl(iteratorZip.ts, 227, 5)) +>a112 : Symbol(a112, Decl(a.ts, 225, 5)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a114 = Iterator.zipKeyed(a112, { mode: "longest", padding: { a: 0 } }).toArray(); ->a114 : Symbol(a114, Decl(iteratorZip.ts, 230, 5)) +>a114 : Symbol(a114, Decl(a.ts, 228, 5)) >Iterator.zipKeyed(a112, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a112 : Symbol(a112, Decl(iteratorZip.ts, 227, 5)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 230, 38)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 230, 55)) ->a : Symbol(a, Decl(iteratorZip.ts, 230, 66)) +>a112 : Symbol(a112, Decl(a.ts, 225, 5)) +>mode : Symbol(mode, Decl(a.ts, 228, 38)) +>padding : Symbol(padding, Decl(a.ts, 228, 55)) +>a : Symbol(a, Decl(a.ts, 228, 66)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a115 = { a: [1, 2], b: "inputs" }; ->a115 : Symbol(a115, Decl(iteratorZip.ts, 232, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 232, 14)) ->b : Symbol(b, Decl(iteratorZip.ts, 232, 25)) +>a115 : Symbol(a115, Decl(a.ts, 230, 5)) +>a : Symbol(a, Decl(a.ts, 230, 14)) +>b : Symbol(b, Decl(a.ts, 230, 25)) const a116 = Iterator.zipKeyed(a115).toArray(); ->a116 : Symbol(a116, Decl(iteratorZip.ts, 233, 5)) +>a116 : Symbol(a116, Decl(a.ts, 231, 5)) >Iterator.zipKeyed(a115).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a115 : Symbol(a115, Decl(iteratorZip.ts, 232, 5)) +>a115 : Symbol(a115, Decl(a.ts, 230, 5)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a117 = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); ->a117 : Symbol(a117, Decl(iteratorZip.ts, 235, 5)) +>a117 : Symbol(a117, Decl(a.ts, 233, 5)) >Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) @@ -1261,137 +1253,137 @@ const a117 = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a118: string = a108[0].b; ->a118 : Symbol(a118, Decl(iteratorZip.ts, 237, 5)) ->a108 : Symbol(a108, Decl(iteratorZip.ts, 222, 5)) +>a118 : Symbol(a118, Decl(a.ts, 235, 5)) +>a108 : Symbol(a108, Decl(a.ts, 220, 5)) const a119: string = a113[0].b; ->a119 : Symbol(a119, Decl(iteratorZip.ts, 238, 5)) ->a113 : Symbol(a113, Decl(iteratorZip.ts, 229, 5)) +>a119 : Symbol(a119, Decl(a.ts, 236, 5)) +>a113 : Symbol(a113, Decl(a.ts, 227, 5)) declare const a120: unique symbol; ->a120 : Symbol(a120, Decl(iteratorZip.ts, 240, 13)) +>a120 : Symbol(a120, Decl(a.ts, 238, 13)) const a121: { a: number; [a120]: string; }[] = Iterator.zipKeyed({ a: [1], [a120]: ["a"] }).toArray(); ->a121 : Symbol(a121, Decl(iteratorZip.ts, 241, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 241, 13)) ->[a120] : Symbol([a120], Decl(iteratorZip.ts, 241, 24)) ->a120 : Symbol(a120, Decl(iteratorZip.ts, 240, 13)) +>a121 : Symbol(a121, Decl(a.ts, 239, 5)) +>a : Symbol(a, Decl(a.ts, 239, 13)) +>[a120] : Symbol([a120], Decl(a.ts, 239, 24)) +>a120 : Symbol(a120, Decl(a.ts, 238, 13)) >Iterator.zipKeyed({ a: [1], [a120]: ["a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 241, 66)) ->[a120] : Symbol([a120], Decl(iteratorZip.ts, 241, 74)) ->a120 : Symbol(a120, Decl(iteratorZip.ts, 240, 13)) +>a : Symbol(a, Decl(a.ts, 239, 66)) +>[a120] : Symbol([a120], Decl(a.ts, 239, 74)) +>a120 : Symbol(a120, Decl(a.ts, 238, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a122: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1] }, { mode: "longest" }).toArray(); ->a122 : Symbol(a122, Decl(iteratorZip.ts, 242, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 242, 13)) +>a122 : Symbol(a122, Decl(a.ts, 240, 5)) +>a : Symbol(a, Decl(a.ts, 240, 13)) >Iterator.zipKeyed({ a: [1] }, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 242, 62)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 242, 74)) +>a : Symbol(a, Decl(a.ts, 240, 62)) +>mode : Symbol(mode, Decl(a.ts, 240, 74)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a123: { a: number; }[] = Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray(); ->a123 : Symbol(a123, Decl(iteratorZip.ts, 243, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 243, 13)) +>a123 : Symbol(a123, Decl(a.ts, 241, 5)) +>a : Symbol(a, Decl(a.ts, 241, 13)) >Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 243, 50)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 243, 62)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 243, 79)) ->a : Symbol(a, Decl(iteratorZip.ts, 243, 90)) +>a : Symbol(a, Decl(a.ts, 241, 50)) +>mode : Symbol(mode, Decl(a.ts, 241, 62)) +>padding : Symbol(padding, Decl(a.ts, 241, 79)) +>a : Symbol(a, Decl(a.ts, 241, 90)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) declare const a124: object; ->a124 : Symbol(a124, Decl(iteratorZip.ts, 245, 13)) +>a124 : Symbol(a124, Decl(a.ts, 243, 13)) const a125 = Iterator.zipKeyed(a124).toArray(); ->a125 : Symbol(a125, Decl(iteratorZip.ts, 246, 5)) +>a125 : Symbol(a125, Decl(a.ts, 244, 5)) >Iterator.zipKeyed(a124).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a124 : Symbol(a124, Decl(iteratorZip.ts, 245, 13)) +>a124 : Symbol(a124, Decl(a.ts, 243, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a126 = Iterator.zipKeyed(a124, { mode: "strict" }).toArray(); ->a126 : Symbol(a126, Decl(iteratorZip.ts, 247, 5)) +>a126 : Symbol(a126, Decl(a.ts, 245, 5)) >Iterator.zipKeyed(a124, { mode: "strict" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a124 : Symbol(a124, Decl(iteratorZip.ts, 245, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 247, 38)) +>a124 : Symbol(a124, Decl(a.ts, 243, 13)) +>mode : Symbol(mode, Decl(a.ts, 245, 38)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a127 = Iterator.zipKeyed(a124, { mode: "longest" }).toArray(); ->a127 : Symbol(a127, Decl(iteratorZip.ts, 248, 5)) +>a127 : Symbol(a127, Decl(a.ts, 246, 5)) >Iterator.zipKeyed(a124, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a124 : Symbol(a124, Decl(iteratorZip.ts, 245, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 248, 38)) +>a124 : Symbol(a124, Decl(a.ts, 243, 13)) +>mode : Symbol(mode, Decl(a.ts, 246, 38)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a128 = Iterator.zipKeyed(a124, { mode: "longest", padding: { a: 0 } }).toArray(); ->a128 : Symbol(a128, Decl(iteratorZip.ts, 249, 5)) +>a128 : Symbol(a128, Decl(a.ts, 247, 5)) >Iterator.zipKeyed(a124, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a124 : Symbol(a124, Decl(iteratorZip.ts, 245, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 249, 38)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 249, 55)) ->a : Symbol(a, Decl(iteratorZip.ts, 249, 66)) +>a124 : Symbol(a124, Decl(a.ts, 243, 13)) +>mode : Symbol(mode, Decl(a.ts, 247, 38)) +>padding : Symbol(padding, Decl(a.ts, 247, 55)) +>a : Symbol(a, Decl(a.ts, 247, 66)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a129: unknown = a125[0].a; ->a129 : Symbol(a129, Decl(iteratorZip.ts, 250, 5)) ->a125 : Symbol(a125, Decl(iteratorZip.ts, 246, 5)) +>a129 : Symbol(a129, Decl(a.ts, 248, 5)) +>a125 : Symbol(a125, Decl(a.ts, 244, 5)) const a130: unknown = a126[0].a; ->a130 : Symbol(a130, Decl(iteratorZip.ts, 251, 5)) ->a126 : Symbol(a126, Decl(iteratorZip.ts, 247, 5)) +>a130 : Symbol(a130, Decl(a.ts, 249, 5)) +>a126 : Symbol(a126, Decl(a.ts, 245, 5)) const a131: unknown = a127[0].a; ->a131 : Symbol(a131, Decl(iteratorZip.ts, 252, 5)) ->a127 : Symbol(a127, Decl(iteratorZip.ts, 248, 5)) +>a131 : Symbol(a131, Decl(a.ts, 250, 5)) +>a127 : Symbol(a127, Decl(a.ts, 246, 5)) const a132: unknown = a128[0].a; ->a132 : Symbol(a132, Decl(iteratorZip.ts, 253, 5)) ->a128 : Symbol(a128, Decl(iteratorZip.ts, 249, 5)) +>a132 : Symbol(a132, Decl(a.ts, 251, 5)) +>a128 : Symbol(a128, Decl(a.ts, 247, 5)) const a133: never[] = a125; ->a133 : Symbol(a133, Decl(iteratorZip.ts, 254, 5)) ->a125 : Symbol(a125, Decl(iteratorZip.ts, 246, 5)) +>a133 : Symbol(a133, Decl(a.ts, 252, 5)) +>a125 : Symbol(a125, Decl(a.ts, 244, 5)) declare const a134: {}; ->a134 : Symbol(a134, Decl(iteratorZip.ts, 256, 13)) +>a134 : Symbol(a134, Decl(a.ts, 254, 13)) const a135 = Iterator.zipKeyed(a134).toArray(); ->a135 : Symbol(a135, Decl(iteratorZip.ts, 257, 5)) +>a135 : Symbol(a135, Decl(a.ts, 255, 5)) >Iterator.zipKeyed(a134).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a134 : Symbol(a134, Decl(iteratorZip.ts, 256, 13)) +>a134 : Symbol(a134, Decl(a.ts, 254, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a136: unknown = a135[0].a; ->a136 : Symbol(a136, Decl(iteratorZip.ts, 258, 5)) ->a135 : Symbol(a135, Decl(iteratorZip.ts, 257, 5)) +>a136 : Symbol(a136, Decl(a.ts, 256, 5)) +>a135 : Symbol(a135, Decl(a.ts, 255, 5)) const a137: never[] = a135; ->a137 : Symbol(a137, Decl(iteratorZip.ts, 259, 5)) ->a135 : Symbol(a135, Decl(iteratorZip.ts, 257, 5)) +>a137 : Symbol(a137, Decl(a.ts, 257, 5)) +>a135 : Symbol(a135, Decl(a.ts, 255, 5)) Iterator.zipKeyed(0); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) @@ -1407,31 +1399,624 @@ Iterator.zipKeyed(a107, { mode: "invalid" }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a107 : Symbol(a107, Decl(iteratorZip.ts, 221, 5)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 263, 25)) +>a107 : Symbol(a107, Decl(a.ts, 219, 5)) +>mode : Symbol(mode, Decl(a.ts, 261, 25)) Iterator.zipKeyed(a107, { mode: "shortest", padding: {} }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a107 : Symbol(a107, Decl(iteratorZip.ts, 221, 5)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 264, 25)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 264, 43)) +>a107 : Symbol(a107, Decl(a.ts, 219, 5)) +>mode : Symbol(mode, Decl(a.ts, 262, 25)) +>padding : Symbol(padding, Decl(a.ts, 262, 43)) Iterator.zipKeyed(a107, { mode: "longest", padding: 0 }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a107 : Symbol(a107, Decl(iteratorZip.ts, 221, 5)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 265, 25)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 265, 42)) +>a107 : Symbol(a107, Decl(a.ts, 219, 5)) +>mode : Symbol(mode, Decl(a.ts, 263, 25)) +>padding : Symbol(padding, Decl(a.ts, 263, 42)) + +const a138: [number | boolean, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }).toArray(); +>a138 : Symbol(a138, Decl(a.ts, 264, 5)) +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>const : Symbol(const) +>mode : Symbol(mode, Decl(a.ts, 264, 92)) +>padding : Symbol(padding, Decl(a.ts, 264, 109)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a139: { a: number | string; b: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: { a: "a" } }).toArray(); +>a139 : Symbol(a139, Decl(a.ts, 265, 5)) +>a : Symbol(a, Decl(a.ts, 265, 13)) +>b : Symbol(b, Decl(a.ts, 265, 33)) +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: { a: "a" } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(a.ts, 265, 82)) +>b : Symbol(b, Decl(a.ts, 265, 90)) +>mode : Symbol(mode, Decl(a.ts, 265, 105)) +>padding : Symbol(padding, Decl(a.ts, 265, 122)) +>a : Symbol(a, Decl(a.ts, 265, 133)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const a140: boolean[]; +>a140 : Symbol(a140, Decl(a.ts, 267, 13)) + +const a141: [number | boolean | undefined, string | boolean | undefined][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a140 }).toArray(); +>a141 : Symbol(a141, Decl(a.ts, 268, 5)) +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: a140 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(a.ts, 268, 105)) +>padding : Symbol(padding, Decl(a.ts, 268, 122)) +>a140 : Symbol(a140, Decl(a.ts, 267, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a142 = Iterator.zip(a12, { mode: "longest", padding: new Set([false]) }).toArray(); +>a142 : Symbol(a142, Decl(a.ts, 269, 5)) +>Iterator.zip(a12, { mode: "longest", padding: new Set([false]) }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>a12 : Symbol(a12, Decl(a.ts, 21, 13)) +>mode : Symbol(mode, Decl(a.ts, 269, 32)) +>padding : Symbol(padding, Decl(a.ts, 269, 49)) +>Set : Symbol(Set, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a143: (number | boolean | undefined)[][] = a142; +>a143 : Symbol(a143, Decl(a.ts, 270, 5)) +>a142 : Symbol(a142, Decl(a.ts, 269, 5)) + +const a144: (number | undefined)[][] = a142; +>a144 : Symbol(a144, Decl(a.ts, 271, 5)) +>a142 : Symbol(a142, Decl(a.ts, 269, 5)) + +const a145: (number | boolean | undefined)[][] = Iterator.zip([[1], [2, 3]], { mode: "longest", padding: new Set([false]) }).toArray(); +>a145 : Symbol(a145, Decl(a.ts, 272, 5)) +>Iterator.zip([[1], [2, 3]], { mode: "longest", padding: new Set([false]) }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(a.ts, 272, 78)) +>padding : Symbol(padding, Decl(a.ts, 272, 95)) +>Set : Symbol(Set, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const a146: { a: boolean; } | { b: string; }; +>a146 : Symbol(a146, Decl(a.ts, 274, 13)) +>a : Symbol(a, Decl(a.ts, 274, 21)) +>b : Symbol(b, Decl(a.ts, 274, 39)) + +const a147 = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a146 }).toArray(); +>a147 : Symbol(a147, Decl(a.ts, 275, 5)) +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a146 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(a.ts, 275, 32)) +>b : Symbol(b, Decl(a.ts, 275, 40)) +>mode : Symbol(mode, Decl(a.ts, 275, 55)) +>padding : Symbol(padding, Decl(a.ts, 275, 72)) +>a146 : Symbol(a146, Decl(a.ts, 274, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a148: { a: number | boolean | undefined; b: number | string | undefined; }[] = a147; +>a148 : Symbol(a148, Decl(a.ts, 276, 5)) +>a : Symbol(a, Decl(a.ts, 276, 13)) +>b : Symbol(b, Decl(a.ts, 276, 46)) +>a147 : Symbol(a147, Decl(a.ts, 275, 5)) + +const a149: { a: number | undefined; b: number | undefined; }[] = a147; +>a149 : Symbol(a149, Decl(a.ts, 277, 5)) +>a : Symbol(a, Decl(a.ts, 277, 13)) +>b : Symbol(b, Decl(a.ts, 277, 36)) +>a147 : Symbol(a147, Decl(a.ts, 275, 5)) + +declare const a150: [boolean] | [string, string]; +>a150 : Symbol(a150, Decl(a.ts, 278, 13)) + +const a151: [number | boolean | string, number | string | undefined][] = Iterator.zip([[1], [2, 3]], { mode: "longest", padding: a150 }).toArray(); +>a151 : Symbol(a151, Decl(a.ts, 279, 5)) +>Iterator.zip([[1], [2, 3]], { mode: "longest", padding: a150 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(a.ts, 279, 102)) +>padding : Symbol(padding, Decl(a.ts, 279, 119)) +>a150 : Symbol(a150, Decl(a.ts, 278, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const a152: { mode: "longest"; padding?: { a: boolean; }; }; +>a152 : Symbol(a152, Decl(a.ts, 281, 13)) +>mode : Symbol(mode, Decl(a.ts, 281, 21)) +>padding : Symbol(padding, Decl(a.ts, 281, 38)) +>a : Symbol(a, Decl(a.ts, 281, 50)) + +const a153 = Iterator.zipKeyed({ a: [1] }, a152).toArray(); +>a153 : Symbol(a153, Decl(a.ts, 282, 5)) +>Iterator.zipKeyed({ a: [1] }, a152).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(a.ts, 282, 32)) +>a152 : Symbol(a152, Decl(a.ts, 281, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a154: { a: number | boolean | undefined; }[] = a153; +>a154 : Symbol(a154, Decl(a.ts, 283, 5)) +>a : Symbol(a, Decl(a.ts, 283, 13)) +>a153 : Symbol(a153, Decl(a.ts, 282, 5)) + +const a155: { a: number | boolean; }[] = a153; +>a155 : Symbol(a155, Decl(a.ts, 284, 5)) +>a : Symbol(a, Decl(a.ts, 284, 13)) +>a153 : Symbol(a153, Decl(a.ts, 282, 5)) + +declare const a156: { mode: "shortest"; } | { mode: "longest"; padding: [boolean]; } | undefined; +>a156 : Symbol(a156, Decl(a.ts, 285, 13)) +>mode : Symbol(mode, Decl(a.ts, 285, 21)) +>mode : Symbol(mode, Decl(a.ts, 285, 45)) +>padding : Symbol(padding, Decl(a.ts, 285, 62)) + +const a157: [number | boolean | undefined][] = Iterator.zip([[1]], a156).toArray(); +>a157 : Symbol(a157, Decl(a.ts, 286, 5)) +>Iterator.zip([[1]], a156).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>a156 : Symbol(a156, Decl(a.ts, 285, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a158: [number][] = Iterator.zip([[1]], { mode: undefined }).toArray(); +>a158 : Symbol(a158, Decl(a.ts, 287, 5)) +>Iterator.zip([[1]], { mode: undefined }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(a.ts, 287, 46)) +>undefined : Symbol(undefined) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a159: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: undefined }).toArray(); +>a159 : Symbol(a159, Decl(a.ts, 288, 5)) +>a : Symbol(a, Decl(a.ts, 288, 13)) +>Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: undefined }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(a.ts, 288, 62)) +>mode : Symbol(mode, Decl(a.ts, 288, 74)) +>padding : Symbol(padding, Decl(a.ts, 288, 91)) +>undefined : Symbol(undefined) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a160: { a: number | { b: string; }; [a1]: boolean | string; }[] = Iterator.zipKeyed({ a: [1], [a1]: [true, false] }, { +>a160 : Symbol(a160, Decl(a.ts, 290, 5)) +>a : Symbol(a, Decl(a.ts, 290, 13)) +>b : Symbol(b, Decl(a.ts, 290, 27)) +>[a1] : Symbol([a1], Decl(a.ts, 290, 41)) +>a1 : Symbol(a1, Decl(a.ts, 0, 13)) +>Iterator.zipKeyed({ a: [1], [a1]: [true, false] }, { mode: "longest", padding: { a: { b: "a" }, [a1]: "a" },}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(a.ts, 290, 91)) +>[a1] : Symbol([a1], Decl(a.ts, 290, 99)) +>a1 : Symbol(a1, Decl(a.ts, 0, 13)) + + mode: "longest", +>mode : Symbol(mode, Decl(a.ts, 290, 124)) + + padding: { a: { b: "a" }, [a1]: "a" }, +>padding : Symbol(padding, Decl(a.ts, 291, 20)) +>a : Symbol(a, Decl(a.ts, 292, 14)) +>b : Symbol(b, Decl(a.ts, 292, 19)) +>[a1] : Symbol([a1], Decl(a.ts, 292, 29)) +>a1 : Symbol(a1, Decl(a.ts, 0, 13)) + +}).toArray(); +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a161: { "0": number | boolean; }[] = Iterator.zipKeyed({ "0": [1] }, { mode: "longest", padding: { 0: false } }).toArray(); +>a161 : Symbol(a161, Decl(a.ts, 294, 5)) +>"0" : Symbol("0", Decl(a.ts, 294, 13)) +>Iterator.zipKeyed({ "0": [1] }, { mode: "longest", padding: { 0: false } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>"0" : Symbol("0", Decl(a.ts, 294, 62)) +>mode : Symbol(mode, Decl(a.ts, 294, 76)) +>padding : Symbol(padding, Decl(a.ts, 294, 93)) +>0 : Symbol(0, Decl(a.ts, 294, 104)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a162: { 0: number | boolean; }[] = Iterator.zipKeyed({ 0: [1] }, { mode: "longest", padding: { "0": false } }).toArray(); +>a162 : Symbol(a162, Decl(a.ts, 295, 5)) +>0 : Symbol(0, Decl(a.ts, 295, 13)) +>Iterator.zipKeyed({ 0: [1] }, { mode: "longest", padding: { "0": false } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>0 : Symbol(0, Decl(a.ts, 295, 60)) +>mode : Symbol(mode, Decl(a.ts, 295, 72)) +>padding : Symbol(padding, Decl(a.ts, 295, 89)) +>"0" : Symbol("0", Decl(a.ts, 295, 100)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a163 = Iterator.zipKeyed({ 0: [1] }, { mode: "longest", padding: { "01": false } }).toArray(); +>a163 : Symbol(a163, Decl(a.ts, 296, 5)) +>Iterator.zipKeyed({ 0: [1] }, { mode: "longest", padding: { "01": false } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>0 : Symbol(0, Decl(a.ts, 296, 32)) +>mode : Symbol(mode, Decl(a.ts, 296, 44)) +>padding : Symbol(padding, Decl(a.ts, 296, 61)) +>"01" : Symbol("01", Decl(a.ts, 296, 72)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a164: { 0: number | undefined; }[] = a163; +>a164 : Symbol(a164, Decl(a.ts, 297, 5)) +>0 : Symbol(0, Decl(a.ts, 297, 13)) +>a163 : Symbol(a163, Decl(a.ts, 296, 5)) + +const a165: { 0: number; }[] = a163; +>a165 : Symbol(a165, Decl(a.ts, 298, 5)) +>0 : Symbol(0, Decl(a.ts, 298, 13)) +>a163 : Symbol(a163, Decl(a.ts, 296, 5)) + +declare const a166: Record; +>a166 : Symbol(a166, Decl(a.ts, 300, 13)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) + +const a167 = Iterator.zipKeyed({ NaN: [1], Infinity: [2], "-Infinity": [3] }, { mode: "longest", padding: a166 }).toArray(); +>a167 : Symbol(a167, Decl(a.ts, 301, 5)) +>Iterator.zipKeyed({ NaN: [1], Infinity: [2], "-Infinity": [3] }, { mode: "longest", padding: a166 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>NaN : Symbol(NaN, Decl(a.ts, 301, 32)) +>Infinity : Symbol(Infinity, Decl(a.ts, 301, 42)) +>"-Infinity" : Symbol("-Infinity", Decl(a.ts, 301, 57)) +>mode : Symbol(mode, Decl(a.ts, 301, 79)) +>padding : Symbol(padding, Decl(a.ts, 301, 96)) +>a166 : Symbol(a166, Decl(a.ts, 300, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a168: { NaN: number | boolean | undefined; Infinity: number | boolean | undefined; "-Infinity": number | boolean | undefined; }[] = a167; +>a168 : Symbol(a168, Decl(a.ts, 302, 5)) +>NaN : Symbol(NaN, Decl(a.ts, 302, 13)) +>Infinity : Symbol(Infinity, Decl(a.ts, 302, 48)) +>"-Infinity" : Symbol("-Infinity", Decl(a.ts, 302, 88)) +>a167 : Symbol(a167, Decl(a.ts, 301, 5)) + +const a169: { NaN: number | undefined; Infinity: number | undefined; "-Infinity": number | undefined; }[] = a167; +>a169 : Symbol(a169, Decl(a.ts, 303, 5)) +>NaN : Symbol(NaN, Decl(a.ts, 303, 13)) +>Infinity : Symbol(Infinity, Decl(a.ts, 303, 38)) +>"-Infinity" : Symbol("-Infinity", Decl(a.ts, 303, 68)) +>a167 : Symbol(a167, Decl(a.ts, 301, 5)) + +const a170 = Iterator.zipKeyed(a58, { mode: "longest", padding: { a: false } }).toArray(); +>a170 : Symbol(a170, Decl(a.ts, 304, 5)) +>Iterator.zipKeyed(a58, { mode: "longest", padding: { a: false } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a58 : Symbol(a58, Decl(a.ts, 145, 5)) +>mode : Symbol(mode, Decl(a.ts, 304, 37)) +>padding : Symbol(padding, Decl(a.ts, 304, 54)) +>a : Symbol(a, Decl(a.ts, 304, 65)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a171: Record[] = a170; +>a171 : Symbol(a171, Decl(a.ts, 305, 5)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>a170 : Symbol(a170, Decl(a.ts, 304, 5)) + +const a172: Record[] = a170; +>a172 : Symbol(a172, Decl(a.ts, 306, 5)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>a170 : Symbol(a170, Decl(a.ts, 304, 5)) + +const a173: [number | undefined, string | undefined][] = Iterator.zip<[Iterable, Iterable]>([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); +>a173 : Symbol(a173, Decl(a.ts, 308, 5)) +>Iterator.zip<[Iterable, Iterable]>([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>mode : Symbol(mode, Decl(a.ts, 308, 123)) +>padding : Symbol(padding, Decl(a.ts, 308, 140)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a174: (number | undefined)[][] = Iterator.zip>(a12, { mode: "longest", padding: [0] }).toArray(); +>a174 : Symbol(a174, Decl(a.ts, 309, 5)) +>Iterator.zip>(a12, { mode: "longest", padding: [0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>a12 : Symbol(a12, Decl(a.ts, 21, 13)) +>mode : Symbol(mode, Decl(a.ts, 309, 76)) +>padding : Symbol(padding, Decl(a.ts, 309, 93)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a175: { a: number | undefined; }[] = Iterator.zipKeyed<{ a: Iterable; }>({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray(); +>a175 : Symbol(a175, Decl(a.ts, 310, 5)) +>a : Symbol(a, Decl(a.ts, 310, 13)) +>Iterator.zipKeyed<{ a: Iterable; }>({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(a.ts, 310, 62)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>a : Symbol(a, Decl(a.ts, 310, 88)) +>mode : Symbol(mode, Decl(a.ts, 310, 100)) +>padding : Symbol(padding, Decl(a.ts, 310, 117)) +>a : Symbol(a, Decl(a.ts, 310, 128)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a176: [number | boolean][] = Iterator.zip<[Iterable], [boolean]>([[1]], { mode: "longest", padding: [false] }).toArray(); +>a176 : Symbol(a176, Decl(a.ts, 311, 5)) +>Iterator.zip<[Iterable], [boolean]>([[1]], { mode: "longest", padding: [false] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>mode : Symbol(mode, Decl(a.ts, 311, 87)) +>padding : Symbol(padding, Decl(a.ts, 311, 104)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a177: { a: number | boolean; }[] = Iterator.zipKeyed<{ a: Iterable; }, { a: boolean; }>({ a: [1] }, { mode: "longest", padding: { a: false } }).toArray(); +>a177 : Symbol(a177, Decl(a.ts, 312, 5)) +>a : Symbol(a, Decl(a.ts, 312, 13)) +>Iterator.zipKeyed<{ a: Iterable; }, { a: boolean; }>({ a: [1] }, { mode: "longest", padding: { a: false } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(a.ts, 312, 60)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>a : Symbol(a, Decl(a.ts, 312, 86)) +>a : Symbol(a, Decl(a.ts, 312, 103)) +>mode : Symbol(mode, Decl(a.ts, 312, 115)) +>padding : Symbol(padding, Decl(a.ts, 312, 132)) +>a : Symbol(a, Decl(a.ts, 312, 143)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +Iterator.zipKeyed<{ a: Iterable; }>({ a: [1] }, { mode: "longest", padding: 0 }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(a.ts, 313, 19)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>a : Symbol(a, Decl(a.ts, 313, 45)) +>mode : Symbol(mode, Decl(a.ts, 313, 57)) +>padding : Symbol(padding, Decl(a.ts, 313, 74)) + +Iterator.zipKeyed<{}>({}, { mode: "longest", padding: 0 }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>mode : Symbol(mode, Decl(a.ts, 314, 27)) +>padding : Symbol(padding, Decl(a.ts, 314, 44)) + +Iterator.zipKeyed<{ a: Iterable; }, {}>({ a: [1] }, { mode: "longest", padding: 0 }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(a.ts, 315, 19)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>a : Symbol(a, Decl(a.ts, 315, 49)) +>mode : Symbol(mode, Decl(a.ts, 315, 61)) +>padding : Symbol(padding, Decl(a.ts, 315, 78)) + +=== b.ts === +export function f1>>(a: T) { +>f1 : Symbol(f1, Decl(b.ts, 0, 0)) +>T : Symbol(T, Decl(b.ts, 0, 19)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>a : Symbol(a, Decl(b.ts, 0, 64)) +>T : Symbol(T, Decl(b.ts, 0, 19)) + + return Iterator.zipKeyed(a); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(b.ts, 0, 64)) +} + +export function f2>>(a: T) { +>f2 : Symbol(f2, Decl(b.ts, 2, 1)) +>T : Symbol(T, Decl(b.ts, 4, 19)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>a : Symbol(a, Decl(b.ts, 4, 64)) +>T : Symbol(T, Decl(b.ts, 4, 19)) + + return Iterator.zipKeyed(a, { mode: "longest" }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(b.ts, 4, 64)) +>mode : Symbol(mode, Decl(b.ts, 5, 33)) +} + +export function f3>>(a: T) { +>f3 : Symbol(f3, Decl(b.ts, 6, 1)) +>T : Symbol(T, Decl(b.ts, 8, 19)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>a : Symbol(a, Decl(b.ts, 8, 64)) +>T : Symbol(T, Decl(b.ts, 8, 19)) + + return Iterator.zipKeyed(a, { mode: "longest", padding: {} }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(b.ts, 8, 64)) +>mode : Symbol(mode, Decl(b.ts, 9, 33)) +>padding : Symbol(padding, Decl(b.ts, 9, 50)) +} + +export function f4(a: T) { +>f4 : Symbol(f4, Decl(b.ts, 10, 1)) +>T : Symbol(T, Decl(b.ts, 12, 19)) +>a : Symbol(a, Decl(b.ts, 12, 37)) +>T : Symbol(T, Decl(b.ts, 12, 19)) + + return Iterator.zipKeyed(a); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(b.ts, 12, 37)) +} + +export function f5(a: Iterable, b: U) { +>f5 : Symbol(f5, Decl(b.ts, 14, 1)) +>T : Symbol(T, Decl(b.ts, 16, 19)) +>U : Symbol(U, Decl(b.ts, 16, 21)) +>a : Symbol(a, Decl(b.ts, 16, 25)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>T : Symbol(T, Decl(b.ts, 16, 19)) +>b : Symbol(b, Decl(b.ts, 16, 40)) +>U : Symbol(U, Decl(b.ts, 16, 21)) + + return Iterator.zipKeyed({ a }, { mode: "longest", padding: { a: b } }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(b.ts, 17, 30)) +>mode : Symbol(mode, Decl(b.ts, 17, 37)) +>padding : Symbol(padding, Decl(b.ts, 17, 54)) +>a : Symbol(a, Decl(b.ts, 17, 65)) +>b : Symbol(b, Decl(b.ts, 16, 40)) +} + +export function f6 | Iterator)[]>(a: T) { +>f6 : Symbol(f6, Decl(b.ts, 18, 1)) +>T : Symbol(T, Decl(b.ts, 20, 19)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(b.ts, 20, 81)) +>T : Symbol(T, Decl(b.ts, 20, 19)) + + return Iterator.zip(a); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>a : Symbol(a, Decl(b.ts, 20, 81)) +} -Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: "invalid" } }); +export function f7(a: Iterable, b: U) { +>f7 : Symbol(f7, Decl(b.ts, 22, 1)) +>T : Symbol(T, Decl(b.ts, 24, 19)) +>U : Symbol(U, Decl(b.ts, 24, 21)) +>a : Symbol(a, Decl(b.ts, 24, 40)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>T : Symbol(T, Decl(b.ts, 24, 19)) +>b : Symbol(b, Decl(b.ts, 24, 55)) +>U : Symbol(U, Decl(b.ts, 24, 21)) + + return Iterator.zipKeyed({ a }, { mode: "longest", padding: b }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(b.ts, 25, 30)) +>mode : Symbol(mode, Decl(b.ts, 25, 37)) +>padding : Symbol(padding, Decl(b.ts, 25, 54)) +>b : Symbol(b, Decl(b.ts, 24, 55)) +} + +export const a = f1({ a: [1], b: ["a"] }).toArray(); +>a : Symbol(a, Decl(b.ts, 28, 12)) +>f1({ a: [1], b: ["a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>f1 : Symbol(f1, Decl(b.ts, 0, 0)) +>a : Symbol(a, Decl(b.ts, 28, 21)) +>b : Symbol(b, Decl(b.ts, 28, 29)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +export const b = f2({ a: [1], b: ["a"] }).toArray(); +>b : Symbol(b, Decl(b.ts, 29, 12)) +>f2({ a: [1], b: ["a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>f2 : Symbol(f2, Decl(b.ts, 2, 1)) +>a : Symbol(a, Decl(b.ts, 29, 21)) +>b : Symbol(b, Decl(b.ts, 29, 29)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +export const c = f3({ a: [1], b: ["a"] }).toArray(); +>c : Symbol(c, Decl(b.ts, 30, 12)) +>f3({ a: [1], b: ["a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>f3 : Symbol(f3, Decl(b.ts, 6, 1)) +>a : Symbol(a, Decl(b.ts, 30, 21)) +>b : Symbol(b, Decl(b.ts, 30, 29)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +export const d = f4({ a: [1], b: ["a"] }).toArray(); +>d : Symbol(d, Decl(b.ts, 31, 12)) +>f4({ a: [1], b: ["a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>f4 : Symbol(f4, Decl(b.ts, 10, 1)) +>a : Symbol(a, Decl(b.ts, 31, 21)) +>b : Symbol(b, Decl(b.ts, 31, 29)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +export const e = f5([1], false).toArray(); +>e : Symbol(e, Decl(b.ts, 32, 12)) +>f5([1], false).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>f5 : Symbol(f5, Decl(b.ts, 14, 1)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +export const f = f6([[1], ["a"]] as const).toArray(); +>f : Symbol(f, Decl(b.ts, 33, 12)) +>f6([[1], ["a"]] as const).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>f6 : Symbol(f6, Decl(b.ts, 18, 1)) +>const : Symbol(const) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +export const g = f7([1], { a: false }).toArray(); +>g : Symbol(g, Decl(b.ts, 34, 12)) +>f7([1], { a: false }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>f7 : Symbol(f7, Decl(b.ts, 22, 1)) +>a : Symbol(a, Decl(b.ts, 34, 26)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +export const h = Iterator.zip; +>h : Symbol(h, Decl(b.ts, 35, 12)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) + +export const i = Iterator.zipKeyed; +>i : Symbol(i, Decl(b.ts, 36, 12)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 266, 19)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 266, 31)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 266, 48)) ->a : Symbol(a, Decl(iteratorZip.ts, 266, 59)) + +export const j = h([[1], ["a"]], { mode: "longest", padding: [false, false] }).toArray(); +>j : Symbol(j, Decl(b.ts, 37, 12)) +>h([[1], ["a"]], { mode: "longest", padding: [false, false] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>h : Symbol(h, Decl(b.ts, 35, 12)) +>mode : Symbol(mode, Decl(b.ts, 37, 34)) +>padding : Symbol(padding, Decl(b.ts, 37, 51)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +export const k = i({ a: [1], b: [2, 3] }, { mode: "longest", padding: { a: false } }).toArray(); +>k : Symbol(k, Decl(b.ts, 38, 12)) +>i({ a: [1], b: [2, 3] }, { mode: "longest", padding: { a: false } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>i : Symbol(i, Decl(b.ts, 36, 12)) +>a : Symbol(a, Decl(b.ts, 38, 20)) +>b : Symbol(b, Decl(b.ts, 38, 28)) +>mode : Symbol(mode, Decl(b.ts, 38, 43)) +>padding : Symbol(padding, Decl(b.ts, 38, 60)) +>a : Symbol(a, Decl(b.ts, 38, 71)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).types b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).types index bf30fca89f801..7fd62f1b8cbf3 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).types +++ b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=false).types @@ -1,6 +1,6 @@ //// [tests/cases/compiler/iteratorZip.ts] //// -=== iteratorZip.ts === +=== a.ts === declare const a1: unique symbol; >a1 : unique symbol @@ -9,9 +9,9 @@ const a2: [number, string][] = Iterator.zip([ >Iterator.zip([ [1, 2], new Set(["a", "b"]),] as const).toArray() : [1 | 2, string][] >Iterator.zip([ [1, 2], new Set(["a", "b"]),] as const).toArray : () => [1 | 2, string][] >Iterator.zip([ [1, 2], new Set(["a", "b"]),] as const) : IteratorObject<[1 | 2, string], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[ [1, 2], new Set(["a", "b"]),] as const : [readonly [1, 2], Set] >[ [1, 2], new Set(["a", "b"]),] : [readonly [1, 2], Set] @@ -44,9 +44,9 @@ const a3: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "shor >Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray() : [1, "a"][] >Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray : () => [1, "a"][] >Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }) : IteratorObject<[1, "a"], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[[1], ["a"]] as const : [readonly [1], readonly ["a"]] >[[1], ["a"]] : [readonly [1], readonly ["a"]] >[1] : readonly [1] @@ -63,9 +63,9 @@ const a4: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "stri >Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray() : [1, "a"][] >Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray : () => [1, "a"][] >Iterator.zip([[1], ["a"]] as const, { mode: "strict" }) : IteratorObject<[1, "a"], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[[1], ["a"]] as const : [readonly [1], readonly ["a"]] >[[1], ["a"]] : [readonly [1], readonly ["a"]] >[1] : readonly [1] @@ -82,20 +82,20 @@ const a5: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "long >Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray() : [number, string][] >Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray : () => [number, string][] >Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }) : IteratorObject<[number, string], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[[1], ["a"]] as const : [readonly [1], readonly ["a"]] >[[1], ["a"]] : [readonly [1], readonly ["a"]] >[1] : readonly [1] >1 : 1 >["a"] : readonly ["a"] >"a" : "a" ->{ mode: "longest", padding: [1, "a"] } : { mode: "longest"; padding: [1, "a"]; } +>{ mode: "longest", padding: [1, "a"] } : { mode: "longest"; padding: [number, string]; } >mode : "longest" >"longest" : "longest" ->padding : [1, "a"] ->[1, "a"] : [1, "a"] +>padding : [number, string] +>[1, "a"] : [number, string] >1 : 1 >"a" : "a" >toArray : () => [number, string][] @@ -105,9 +105,9 @@ const a6: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] >Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray() : [1 | undefined, "a" | undefined][] >Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray : () => [1 | undefined, "a" | undefined][] >Iterator.zip([[1], ["a"]] as const, { mode: "longest" }) : IteratorObject<[1 | undefined, "a" | undefined], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[[1], ["a"]] as const : [readonly [1], readonly ["a"]] >[[1], ["a"]] : [readonly [1], readonly ["a"]] >[1] : readonly [1] @@ -124,20 +124,20 @@ const a7: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] >Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray() : [number, "a" | undefined][] >Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray : () => [number, "a" | undefined][] >Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }) : IteratorObject<[number, "a" | undefined], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[[1], ["a"]] as const : [readonly [1], readonly ["a"]] >[[1], ["a"]] : [readonly [1], readonly ["a"]] >[1] : readonly [1] >1 : 1 >["a"] : readonly ["a"] >"a" : "a" ->{ mode: "longest", padding: [1] } : { mode: "longest"; padding: [1]; } +>{ mode: "longest", padding: [1] } : { mode: "longest"; padding: [number]; } >mode : "longest" >"longest" : "longest" ->padding : [1] ->[1] : [1] +>padding : [number] +>[1] : [number] >1 : 1 >toArray : () => [number, "a" | undefined][] @@ -151,9 +151,9 @@ const a9: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] >Iterator.zip([[1], ["a"]] as const, a8).toArray() : [1 | undefined, "a" | undefined][] >Iterator.zip([[1], ["a"]] as const, a8).toArray : () => [1 | undefined, "a" | undefined][] >Iterator.zip([[1], ["a"]] as const, a8) : IteratorObject<[1 | undefined, "a" | undefined], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[[1], ["a"]] as const : [readonly [1], readonly ["a"]] >[[1], ["a"]] : [readonly [1], readonly ["a"]] >[1] : readonly [1] @@ -168,9 +168,9 @@ const a10: never[] = Iterator.zip([]).toArray(); >Iterator.zip([]).toArray() : never[] >Iterator.zip([]).toArray : () => never[] >Iterator.zip([]) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[] : [] >toArray : () => never[] @@ -179,9 +179,9 @@ const a11: never[] = Iterator.zip([], { mode: "longest" }).toArray(); >Iterator.zip([], { mode: "longest" }).toArray() : never[] >Iterator.zip([], { mode: "longest" }).toArray : () => never[] >Iterator.zip([], { mode: "longest" }) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[] : [] >{ mode: "longest" } : { mode: "longest"; } >mode : "longest" @@ -196,9 +196,9 @@ const a13: number[][] = Iterator.zip(a12).toArray(); >Iterator.zip(a12).toArray() : number[][] >Iterator.zip(a12).toArray : () => number[][] >Iterator.zip(a12) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >a12 : Iterable> >toArray : () => number[][] @@ -207,9 +207,9 @@ const a14: (number | undefined)[][] = Iterator.zip(a12, { mode: "longest" }).toA >Iterator.zip(a12, { mode: "longest" }).toArray() : (number | undefined)[][] >Iterator.zip(a12, { mode: "longest" }).toArray : () => (number | undefined)[][] >Iterator.zip(a12, { mode: "longest" }) : IteratorObject<(number | undefined)[], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >a12 : Iterable> >{ mode: "longest" } : { mode: "longest"; } >mode : "longest" @@ -221,9 +221,9 @@ const a15: (number | undefined)[][] = Iterator.zip(a12, a8).toArray(); >Iterator.zip(a12, a8).toArray() : (number | undefined)[][] >Iterator.zip(a12, a8).toArray : () => (number | undefined)[][] >Iterator.zip(a12, a8) : IteratorObject<(number | undefined)[], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >a12 : Iterable> >a8 : { mode: "shortest"; } | { mode: "longest"; } >toArray : () => (number | undefined)[][] @@ -236,9 +236,9 @@ const a17: (number | undefined)[][] = Iterator.zip(a16, { mode: "longest", paddi >Iterator.zip(a16, { mode: "longest", padding: [] }).toArray() : (number | undefined)[][] >Iterator.zip(a16, { mode: "longest", padding: [] }).toArray : () => (number | undefined)[][] >Iterator.zip(a16, { mode: "longest", padding: [] }) : IteratorObject<(number | undefined)[], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >a16 : Iterable[] >{ mode: "longest", padding: [] } : { mode: "longest"; padding: []; } >mode : "longest" @@ -256,9 +256,9 @@ const a18: { a: number; b: string; [a1]: boolean; }[] = Iterator.zipKeyed({ >Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [a1]: [true, false],} as const).toArray() : ({ a: 1 | 2; b: string; [a1]: boolean; } & {})[] >Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [a1]: [true, false],} as const).toArray : () => ({ a: 1 | 2; b: string; [a1]: boolean; } & {})[] >Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [a1]: [true, false],} as const) : IteratorObject<{ a: 1 | 2; b: string; [a1]: boolean; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: [1, 2], b: new Set(["a", "b"]), [a1]: [true, false],} as const : { readonly a: readonly [1, 2]; readonly b: Set; readonly [a1]: readonly [true, false]; } >{ a: [1, 2], b: new Set(["a", "b"]), [a1]: [true, false],} : { readonly a: readonly [1, 2]; readonly b: Set; readonly [a1]: readonly [true, false]; } @@ -302,9 +302,9 @@ const a19: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}).toArray() : ({ a: number; b: string; } & {})[] >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}).toArray : () => ({ a: number; b: string; } & {})[] >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}) : IteratorObject<{ a: number; b: string; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >a : readonly [1] @@ -313,18 +313,18 @@ const a19: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } >b : readonly ["a"] >["a"] : readonly ["a"] >"a" : "a" ->{ mode: "longest", padding: { a: 1, b: "a" },} : { mode: "longest"; padding: { a: 1; b: "a"; }; } +>{ mode: "longest", padding: { a: 1, b: "a" },} : { mode: "longest"; padding: { a: number; b: string; }; } mode: "longest", >mode : "longest" >"longest" : "longest" padding: { a: 1, b: "a" }, ->padding : { a: 1; b: "a"; } ->{ a: 1, b: "a" } : { a: 1; b: "a"; } ->a : 1 +>padding : { a: number; b: string; } +>{ a: 1, b: "a" } : { a: number; b: string; } +>a : number >1 : 1 ->b : "a" +>b : string >"a" : "a" }).toArray(); @@ -337,9 +337,9 @@ const a20: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKey >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}).toArray() : ({ a: 1 | undefined; b: "a" | undefined; } & {})[] >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}).toArray : () => ({ a: 1 | undefined; b: "a" | undefined; } & {})[] >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}) : IteratorObject<{ a: 1 | undefined; b: "a" | undefined; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >a : readonly [1] @@ -364,9 +364,9 @@ const a21: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKey >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}).toArray() : ({ a: 1 | undefined; b: string; } & {})[] >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}).toArray : () => ({ a: 1 | undefined; b: string; } & {})[] >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}) : IteratorObject<{ a: 1 | undefined; b: string; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >a : readonly [1] @@ -375,16 +375,16 @@ const a21: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKey >b : readonly ["a"] >["a"] : readonly ["a"] >"a" : "a" ->{ mode: "longest", padding: { b: "a" },} : { mode: "longest"; padding: { b: "a"; }; } +>{ mode: "longest", padding: { b: "a" },} : { mode: "longest"; padding: { b: string; }; } mode: "longest", >mode : "longest" >"longest" : "longest" padding: { b: "a" }, ->padding : { b: "a"; } ->{ b: "a" } : { b: "a"; } ->b : "a" +>padding : { b: string; } +>{ b: "a" } : { b: string; } +>b : string >"a" : "a" }).toArray(); @@ -397,9 +397,9 @@ const a22: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKey >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, a8).toArray() : ({ a: 1 | undefined; b: "a" | undefined; } & {})[] >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, a8).toArray : () => ({ a: 1 | undefined; b: "a" | undefined; } & {})[] >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, a8) : IteratorObject<{ a: 1 | undefined; b: "a" | undefined; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >a : readonly [1] @@ -429,17 +429,17 @@ const a24: { a: number; b: string; }[] = Iterator.zipKeyed(a23).toArray(); >Iterator.zipKeyed(a23).toArray() : ({ a: number; b: string; } & {})[] >Iterator.zipKeyed(a23).toArray : () => ({ a: number; b: string; } & {})[] >Iterator.zipKeyed(a23) : IteratorObject<{ a: number; b: string; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a23 : I1 >toArray : () => ({ a: number; b: string; } & {})[] Iterator.zip([[1]], { mode: "invalid" }); >Iterator.zip([[1]], { mode: "invalid" }) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[[1]] : [number[]] >[1] : number[] >1 : 1 @@ -447,29 +447,11 @@ Iterator.zip([[1]], { mode: "invalid" }); >mode : "invalid" >"invalid" : "invalid" -Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }); ->Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->[[1], ["a"]] as const : readonly [readonly [1], readonly ["a"]] ->[[1], ["a"]] : readonly [readonly [1], readonly ["a"]] ->[1] : readonly [1] ->1 : 1 ->["a"] : readonly ["a"] ->"a" : "a" ->{ mode: "longest", padding: [true] } : { mode: "longest"; padding: boolean[]; } ->mode : "longest" ->"longest" : "longest" ->padding : boolean[] ->[true] : boolean[] ->true : true - Iterator.zip([[1]], { mode: "shortest", padding: [1] }); >Iterator.zip([[1]], { mode: "shortest", padding: [1] }) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[[1]] : [number[]] >[1] : number[] >1 : 1 @@ -482,16 +464,16 @@ Iterator.zip([[1]], { mode: "shortest", padding: [1] }); Iterator.zip(0); >Iterator.zip(0) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >0 : 0 Iterator.zipKeyed({ a: 0 }); >Iterator.zipKeyed({ a: 0 }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: 0 } : { a: number; } >a : number >0 : 0 @@ -501,9 +483,9 @@ const a25: Record[] = Iterator.zipKeyed({}).toArray(); >Iterator.zipKeyed({}).toArray() : Record[] >Iterator.zipKeyed({}).toArray : () => Record[] >Iterator.zipKeyed({}) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{} : {} >toArray : () => Record[] @@ -512,9 +494,9 @@ const a26: Record[] = Iterator.zipKeyed({}, { mode: "longe >Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray() : Record[] >Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray : () => Record[] >Iterator.zipKeyed({}, { mode: "longest", padding: {} }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{} : {} >{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } >mode : "longest" @@ -535,32 +517,32 @@ const a28: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(a27).toArray( >Iterator.zipKeyed(a27).toArray() : (({ a: number; } & {}) | ({ b: string; } & {}))[] >Iterator.zipKeyed(a27).toArray : () => (({ a: number; } & {}) | ({ b: string; } & {}))[] >Iterator.zipKeyed(a27) : IteratorObject<({ a: number; } & {}) | ({ b: string; } & {}), undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a27 : { a: Iterable; } | { b: Iterator; } >toArray : () => (({ a: number; } & {}) | ({ b: string; } & {}))[] Iterator.zip("ab"); >Iterator.zip("ab") : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >"ab" : "ab" Iterator.zip(["ab"]); >Iterator.zip(["ab"]) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >["ab"] : [string] >"ab" : "ab" Iterator.zip(new Set(["ab"])); >Iterator.zip(new Set(["ab"])) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >new Set(["ab"]) : Set >Set : SetConstructor >["ab"] : string[] @@ -568,25 +550,25 @@ Iterator.zip(new Set(["ab"])); Iterator.zipKeyed("ab"); >Iterator.zipKeyed("ab") : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >"ab" : "ab" Iterator.zipKeyed({ a: "ab" }); >Iterator.zipKeyed({ a: "ab" }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: "ab" } : { a: string; } >a : string >"ab" : "ab" Iterator.zip([], { mode: "longest", padding: "ab" }); >Iterator.zip([], { mode: "longest", padding: "ab" }) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[] : [] >{ mode: "longest", padding: "ab" } : { mode: "longest"; padding: string; } >mode : "longest" @@ -596,9 +578,9 @@ Iterator.zip([], { mode: "longest", padding: "ab" }); Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); >Iterator.zip([["a"]], { mode: "longest", padding: "ab" }) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[["a"]] : [string[]] >["a"] : string[] >"a" : "a" @@ -610,9 +592,9 @@ Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); >Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{} : {} >{ mode: "longest", padding: "ab" } : { mode: "longest"; padding: string; } >mode : "longest" @@ -625,9 +607,9 @@ const a29: [string][] = Iterator.zip([new String("ab")]).toArray(); >Iterator.zip([new String("ab")]).toArray() : [string][] >Iterator.zip([new String("ab")]).toArray : () => [string][] >Iterator.zip([new String("ab")]) : IteratorObject<[string], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[new String("ab")] : [String] >new String("ab") : String >String : StringConstructor @@ -640,9 +622,9 @@ const a30: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray >Iterator.zipKeyed({ a: new String("ab") }).toArray() : ({ a: string; } & {})[] >Iterator.zipKeyed({ a: new String("ab") }).toArray : () => ({ a: string; } & {})[] >Iterator.zipKeyed({ a: new String("ab") }) : IteratorObject<{ a: string; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: new String("ab") } : { a: String; } >a : String >new String("ab") : String @@ -655,9 +637,9 @@ const a31: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", p >Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray() : (string | undefined)[][] >Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray : () => (string | undefined)[][] >Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }) : IteratorObject<(string | undefined)[], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[["a"]] : string[][] >["a"] : string[] >"a" : "a" @@ -675,9 +657,9 @@ const a32 = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); >Iterator.zipKeyed({ a: [1], b: undefined }).toArray() : ({ a: number; } & {})[] >Iterator.zipKeyed({ a: [1], b: undefined }).toArray : () => ({ a: number; } & {})[] >Iterator.zipKeyed({ a: [1], b: undefined }) : IteratorObject<{ a: number; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: [1], b: undefined } : { a: number[]; b: undefined; } >a : number[] >[1] : number[] @@ -703,9 +685,9 @@ const a34: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); >Iterator.zipKeyed({ a: undefined }).toArray() : never[] >Iterator.zipKeyed({ a: undefined }).toArray : () => never[] >Iterator.zipKeyed({ a: undefined }) : IteratorObject ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: undefined } : { a: undefined; } >a : undefined >undefined : undefined @@ -716,9 +698,9 @@ const a35: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padd >Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray() : never[] >Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray : () => never[] >Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }) : IteratorObject ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: undefined } : { a: undefined; } >a : undefined >undefined : undefined @@ -750,9 +732,9 @@ const a37 = Iterator.zipKeyed(a36).toArray(); >Iterator.zipKeyed(a36).toArray() : ({ a: number; } & { b?: string | undefined; c?: boolean | undefined; })[] >Iterator.zipKeyed(a36).toArray : () => ({ a: number; } & { b?: string | undefined; c?: boolean | undefined; })[] >Iterator.zipKeyed(a36) : IteratorObject<{ a: number; } & { b?: string | undefined; c?: boolean | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a36 : I2 >toArray : () => ({ a: number; } & { b?: string | undefined; c?: boolean | undefined; })[] @@ -811,9 +793,9 @@ const a40: { a: number | undefined; b?: string | undefined; c?: boolean | undefi >Iterator.zipKeyed(a36, { mode: "longest" }).toArray() : ({ a: number | undefined; } & { b?: string | undefined; c?: boolean | undefined; })[] >Iterator.zipKeyed(a36, { mode: "longest" }).toArray : () => ({ a: number | undefined; } & { b?: string | undefined; c?: boolean | undefined; })[] >Iterator.zipKeyed(a36, { mode: "longest" }) : IteratorObject<{ a: number | undefined; } & { b?: string | undefined; c?: boolean | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a36 : I2 >{ mode: "longest" } : { mode: "longest"; } >mode : "longest" @@ -832,9 +814,9 @@ const a42: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(a41).toArray( >Iterator.zipKeyed(a41).toArray() : (({ a: number; } & {}) | ({ b: string; } & {}))[] >Iterator.zipKeyed(a41).toArray : () => (({ a: number; } & {}) | ({ b: string; } & {}))[] >Iterator.zipKeyed(a41) : IteratorObject<({ a: number; } & {}) | ({ b: string; } & {}), undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a41 : { a: Iterable; } | { b: Iterator; } >toArray : () => (({ a: number; } & {}) | ({ b: string; } & {}))[] @@ -845,16 +827,16 @@ declare const a43: { a: Iterable; } | { b: number; }; Iterator.zipKeyed(a43); >Iterator.zipKeyed(a43) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a43 : { a: Iterable; } | { b: number; } Iterator.zipKeyed(a43, { mode: "longest" }); >Iterator.zipKeyed(a43, { mode: "longest" }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a43 : { a: Iterable; } | { b: number; } >{ mode: "longest" } : { mode: "longest"; } >mode : "longest" @@ -862,9 +844,9 @@ Iterator.zipKeyed(a43, { mode: "longest" }); Iterator.zipKeyed(a43, { mode: "longest", padding: {} }); >Iterator.zipKeyed(a43, { mode: "longest", padding: {} }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a43 : { a: Iterable; } | { b: number; } >{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } >mode : "longest" @@ -879,9 +861,9 @@ declare const a44: { a?: Iterable; } | { b: string; }; Iterator.zipKeyed(a44); >Iterator.zipKeyed(a44) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a44 : { a?: Iterable; } | { b: string; } declare const a45: { a: Iterable; } | { b: undefined; }; @@ -895,9 +877,9 @@ const a46: { a: number; }[] = Iterator.zipKeyed(a45).toArray(); >Iterator.zipKeyed(a45).toArray() : ({ a: number; } & {})[] >Iterator.zipKeyed(a45).toArray : () => ({ a: number; } & {})[] >Iterator.zipKeyed(a45) : IteratorObject<{ a: number; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a45 : { a: Iterable; } | { b: undefined; } >toArray : () => ({ a: number; } & {})[] @@ -918,17 +900,17 @@ const a49: { a: number; [a47]?: string; }[] = Iterator.zipKeyed(a48).toArray(); >Iterator.zipKeyed(a48).toArray() : ({ a: number; } & { [a47]?: string | undefined; })[] >Iterator.zipKeyed(a48).toArray : () => ({ a: number; } & { [a47]?: string | undefined; })[] >Iterator.zipKeyed(a48) : IteratorObject<{ a: number; } & { [a47]?: string | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a48 : { a: Iterable; [a47]?: Iterable; } >toArray : () => ({ a: number; } & { [a47]?: string | undefined; })[] Iterator.zipKeyed({ a: [1], b: null }); >Iterator.zipKeyed({ a: [1], b: null }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: [1], b: null } : { a: number[]; b: null; } >a : number[] >[1] : number[] @@ -937,9 +919,9 @@ Iterator.zipKeyed({ a: [1], b: null }); Iterator.zipKeyed({ a: [1], b: false }); >Iterator.zipKeyed({ a: [1], b: false }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: [1], b: false } : { a: number[]; b: false; } >a : number[] >[1] : number[] @@ -949,9 +931,9 @@ Iterator.zipKeyed({ a: [1], b: false }); Iterator.zip([undefined]); >Iterator.zip([undefined]) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[undefined] : [undefined] >undefined : undefined @@ -964,9 +946,9 @@ const a51: never[] = Iterator.zipKeyed(a50).toArray(); >Iterator.zipKeyed(a50).toArray() : never[] >Iterator.zipKeyed(a50).toArray : () => never[] >Iterator.zipKeyed(a50) : IteratorObject ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a50 : { a?: undefined; } >toArray : () => never[] @@ -976,9 +958,9 @@ const a52: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode >Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray() : ({ a: number; } & {})[] >Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray : () => ({ a: number; } & {})[] >Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }) : IteratorObject<{ a: number; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: [1], b: undefined } : { a: number[]; b: undefined; } >a : number[] >[1] : number[] @@ -1000,9 +982,9 @@ const a53: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefin >Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray() : ({ a: number | undefined; } & {})[] >Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray : () => ({ a: number | undefined; } & {})[] >Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }) : IteratorObject<{ a: number | undefined; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: [1], b: undefined } : { a: number[]; b: undefined; } >a : number[] >[1] : number[] @@ -1024,9 +1006,9 @@ function f1(a: Iterable) { >Iterator.zipKeyed({ a }).toArray() : ({ a: T; } & {})[] >Iterator.zipKeyed({ a }).toArray : () => ({ a: T; } & {})[] >Iterator.zipKeyed({ a }) : IteratorObject<{ a: T; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a } : { a: Iterable; } >a : Iterable >toArray : () => ({ a: T; } & {})[] @@ -1036,9 +1018,9 @@ function f1(a: Iterable) { >Iterator.zip([a]).toArray() : [T][] >Iterator.zip([a]).toArray : () => [T][] >Iterator.zip([a]) : IteratorObject<[T], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T_1, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T_1, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T_1, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T_1 extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T_1 extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T_1, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T_1, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T_1, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T_1 extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T_1 extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T_1 extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T_1, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T_1, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T_1, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T_1 extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T_1 extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T_1, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T_1, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T_1, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T_1 extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T_1 extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T_1 extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[a] : [Iterable] >a : Iterable >toArray : () => [T][] @@ -1063,9 +1045,9 @@ const a55 = Iterator.zip(a54, { mode: "longest", padding: [0] }).toArray(); >Iterator.zip(a54, { mode: "longest", padding: [0] }).toArray() : [number, ...(number | undefined)[]][] >Iterator.zip(a54, { mode: "longest", padding: [0] }).toArray : () => [number, ...(number | undefined)[]][] >Iterator.zip(a54, { mode: "longest", padding: [0] }) : IteratorObject<[number, ...(number | undefined)[]], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >a54 : [Iterable, ...Iterable[]] >{ mode: "longest", padding: [0] } : { mode: "longest"; padding: [number]; } >mode : "longest" @@ -1099,9 +1081,9 @@ const a59 = Iterator.zipKeyed(a58, { mode: "longest", padding: {} }).toArray(); >Iterator.zipKeyed(a58, { mode: "longest", padding: {} }).toArray() : ({ [x: string]: number | undefined; } & {})[] >Iterator.zipKeyed(a58, { mode: "longest", padding: {} }).toArray : () => ({ [x: string]: number | undefined; } & {})[] >Iterator.zipKeyed(a58, { mode: "longest", padding: {} }) : IteratorObject<{ [x: string]: number | undefined; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a58 : Record> >{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } >mode : "longest" @@ -1126,9 +1108,9 @@ const a63 = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: >Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a62 }).toArray() : ({ a: number | undefined; b: number | undefined; } & {})[] >Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a62 }).toArray : () => ({ a: number | undefined; b: number | undefined; } & {})[] >Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a62 }) : IteratorObject<{ a: number | undefined; b: number | undefined; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: [1], b: [2, 3] } : { a: number[]; b: number[]; } >a : number[] >[1] : number[] @@ -1161,9 +1143,9 @@ const a66 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).to >Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray() : [number, string][] >Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray : () => [number, string][] >Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }) : IteratorObject<[number, string], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[[1], ["a"]] : [number[], string[]] >[1] : number[] >1 : 1 @@ -1187,9 +1169,9 @@ const a68 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: >Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray() : ({ a: number; b: string; } & {})[] >Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray : () => ({ a: number; b: string; } & {})[] >Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }) : IteratorObject<{ a: number; b: string; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } >a : number[] >[1] : number[] @@ -1219,9 +1201,9 @@ const a70 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArra >Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray() : [number, string | undefined][] >Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray : () => [number, string | undefined][] >Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }) : IteratorObject<[number, string | undefined], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[[1], ["a"]] : [number[], string[]] >[1] : number[] >1 : 1 @@ -1248,9 +1230,9 @@ const a73 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: >Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray() : ({ a: number; b: string | undefined; } & {})[] >Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray : () => ({ a: number; b: string | undefined; } & {})[] >Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }) : IteratorObject<{ a: number; b: string | undefined; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } >a : number[] >[1] : number[] @@ -1287,9 +1269,9 @@ const a77: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", pa >Iterator.zip([[1], ["a"]], { mode: "longest", padding: a76 }).toArray() : [number, string][] >Iterator.zip([[1], ["a"]], { mode: "longest", padding: a76 }).toArray : () => [number, string][] >Iterator.zip([[1], ["a"]], { mode: "longest", padding: a76 }) : IteratorObject<[number, string], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[[1], ["a"]] : [number[], string[]] >[1] : number[] >1 : 1 @@ -1310,9 +1292,9 @@ const a79 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a78 }).toArra >Iterator.zip([[1], ["a"]], { mode: "longest", padding: a78 }).toArray() : [number, string | undefined][] >Iterator.zip([[1], ["a"]], { mode: "longest", padding: a78 }).toArray : () => [number, string | undefined][] >Iterator.zip([[1], ["a"]], { mode: "longest", padding: a78 }) : IteratorObject<[number, string | undefined], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[[1], ["a"]] : [number[], string[]] >[1] : number[] >1 : 1 @@ -1337,9 +1319,9 @@ const a82 = Iterator.zip(a81, { mode: "longest", padding: [0] }).toArray(); >Iterator.zip(a81, { mode: "longest", padding: [0] }).toArray() : ([number] | [number, number | undefined])[] >Iterator.zip(a81, { mode: "longest", padding: [0] }).toArray : () => ([number] | [number, number | undefined])[] >Iterator.zip(a81, { mode: "longest", padding: [0] }) : IteratorObject<[number] | [number, number | undefined], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >a81 : [Iterable] | [Iterable, Iterable] >{ mode: "longest", padding: [0] } : { mode: "longest"; padding: [number]; } >mode : "longest" @@ -1363,9 +1345,9 @@ const a85 = Iterator.zipKeyed(a84, { mode: "longest", padding: { a: 0 } }).toArr >Iterator.zipKeyed(a84, { mode: "longest", padding: { a: 0 } }).toArray() : (({ a: number; } & {}) | ({ b: string | undefined; } & {}))[] >Iterator.zipKeyed(a84, { mode: "longest", padding: { a: 0 } }).toArray : () => (({ a: number; } & {}) | ({ b: string | undefined; } & {}))[] >Iterator.zipKeyed(a84, { mode: "longest", padding: { a: 0 } }) : IteratorObject<({ a: number; } & {}) | ({ b: string | undefined; } & {}), undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a84 : { a: Iterable; } | { b: Iterable; } >{ mode: "longest", padding: { a: 0 } } : { mode: "longest"; padding: { a: number; }; } >mode : "longest" @@ -1392,9 +1374,9 @@ const a88 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: >Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: a87 }).toArray() : ({ a: number | undefined; b: string | undefined; } & {})[] >Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: a87 }).toArray : () => ({ a: number | undefined; b: string | undefined; } & {})[] >Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: a87 }) : IteratorObject<{ a: number | undefined; b: string | undefined; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } >a : number[] >[1] : number[] @@ -1420,9 +1402,9 @@ const a90 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { >Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray() : ({ a: number | undefined; b: number; } & {})[] >Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray : () => ({ a: number | undefined; b: number; } & {})[] >Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }) : IteratorObject<{ a: number | undefined; b: number; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: [1], b: [2] } : { a: number[]; b: number[]; } >a : number[] >[1] : number[] @@ -1455,9 +1437,9 @@ const a93 = Iterator.zipKeyed(a92, { mode: "longest", padding: {} }).toArray(); >Iterator.zipKeyed(a92, { mode: "longest", padding: {} }).toArray() : ({ [x: `a${string}`]: number | undefined; } & {})[] >Iterator.zipKeyed(a92, { mode: "longest", padding: {} }).toArray : () => ({ [x: `a${string}`]: number | undefined; } & {})[] >Iterator.zipKeyed(a92, { mode: "longest", padding: {} }) : IteratorObject<{ [x: `a${string}`]: number | undefined; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a92 : { [x: `a${string}`]: Iterable; } >{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } >mode : "longest" @@ -1480,9 +1462,9 @@ const a96: { [a95]: number; }[] = Iterator.zipKeyed({ [a95]: [1] }, { mode: "lon >Iterator.zipKeyed({ [a95]: [1] }, { mode: "longest", padding: { [a95]: 0 } }).toArray() : ({ [a95]: number; } & {})[] >Iterator.zipKeyed({ [a95]: [1] }, { mode: "longest", padding: { [a95]: 0 } }).toArray : () => ({ [a95]: number; } & {})[] >Iterator.zipKeyed({ [a95]: [1] }, { mode: "longest", padding: { [a95]: 0 } }) : IteratorObject<{ [a95]: number; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ [a95]: [1] } : { [a95]: number[]; } >[a95] : number[] >a95 : unique symbol @@ -1507,9 +1489,9 @@ const a98 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: a9 >Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: a97 }).toArray() : ({ a: number; b: number | undefined; } & {})[] >Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: a97 }).toArray : () => ({ a: number; b: number | undefined; } & {})[] >Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: a97 }) : IteratorObject<{ a: number; b: number | undefined; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: [1], b: [2] } : { a: number[]; b: number[]; } >a : number[] >[1] : number[] @@ -1544,9 +1526,9 @@ const a102 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a101 }).toAr >Iterator.zip([[1], ["a"]], { mode: "longest", padding: a101 }).toArray() : [number, string | undefined][] >Iterator.zip([[1], ["a"]], { mode: "longest", padding: a101 }).toArray : () => [number, string | undefined][] >Iterator.zip([[1], ["a"]], { mode: "longest", padding: a101 }) : IteratorObject<[number, string | undefined], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[[1], ["a"]] : [number[], string[]] >[1] : number[] >1 : 1 @@ -1572,9 +1554,9 @@ const a105: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "l >Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray() : [number | undefined, number][] >Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray : () => [number | undefined, number][] >Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }) : IteratorObject<[number | undefined, number], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[[1], [2]] : [number[], number[]] >[1] : number[] >1 : 1 @@ -1631,9 +1613,9 @@ const a108 = Iterator.zipKeyed(a107).toArray(); >Iterator.zipKeyed(a107).toArray() : Record[] >Iterator.zipKeyed(a107).toArray : () => Record[] >Iterator.zipKeyed(a107) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a107 : C1 >toArray : () => Record[] @@ -1642,9 +1624,9 @@ const a109 = Iterator.zipKeyed(a107, { mode: "strict" }).toArray(); >Iterator.zipKeyed(a107, { mode: "strict" }).toArray() : Record[] >Iterator.zipKeyed(a107, { mode: "strict" }).toArray : () => Record[] >Iterator.zipKeyed(a107, { mode: "strict" }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a107 : C1 >{ mode: "strict" } : { mode: "strict"; } >mode : "strict" @@ -1656,9 +1638,9 @@ const a110 = Iterator.zipKeyed(a107, { mode: "longest" }).toArray(); >Iterator.zipKeyed(a107, { mode: "longest" }).toArray() : Record[] >Iterator.zipKeyed(a107, { mode: "longest" }).toArray : () => Record[] >Iterator.zipKeyed(a107, { mode: "longest" }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a107 : C1 >{ mode: "longest" } : { mode: "longest"; } >mode : "longest" @@ -1670,9 +1652,9 @@ const a111 = Iterator.zipKeyed(a107, { mode: "longest", padding: { a: 0 } }).toA >Iterator.zipKeyed(a107, { mode: "longest", padding: { a: 0 } }).toArray() : Record[] >Iterator.zipKeyed(a107, { mode: "longest", padding: { a: 0 } }).toArray : () => Record[] >Iterator.zipKeyed(a107, { mode: "longest", padding: { a: 0 } }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a107 : C1 >{ mode: "longest", padding: { a: 0 } } : { mode: "longest"; padding: { a: number; }; } >mode : "longest" @@ -1709,9 +1691,9 @@ const a113 = Iterator.zipKeyed(a112).toArray(); >Iterator.zipKeyed(a112).toArray() : Record[] >Iterator.zipKeyed(a112).toArray : () => Record[] >Iterator.zipKeyed(a112) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a112 : { a: number[]; b: string; } >toArray : () => Record[] @@ -1720,9 +1702,9 @@ const a114 = Iterator.zipKeyed(a112, { mode: "longest", padding: { a: 0 } }).toA >Iterator.zipKeyed(a112, { mode: "longest", padding: { a: 0 } }).toArray() : Record[] >Iterator.zipKeyed(a112, { mode: "longest", padding: { a: 0 } }).toArray : () => Record[] >Iterator.zipKeyed(a112, { mode: "longest", padding: { a: 0 } }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a112 : { a: number[]; b: string; } >{ mode: "longest", padding: { a: 0 } } : { mode: "longest"; padding: { a: number; }; } >mode : "longest" @@ -1748,9 +1730,9 @@ const a116 = Iterator.zipKeyed(a115).toArray(); >Iterator.zipKeyed(a115).toArray() : Record[] >Iterator.zipKeyed(a115).toArray : () => Record[] >Iterator.zipKeyed(a115) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a115 : { a: number[]; b: string; } >toArray : () => Record[] @@ -1759,9 +1741,9 @@ const a117 = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); >Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray() : Record[] >Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray : () => Record[] >Iterator.zipKeyed([[1, 2], ["a", "b"]]) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >[[1, 2], ["a", "b"]] : (string[] | number[])[] >[1, 2] : number[] >1 : 1 @@ -1798,9 +1780,9 @@ const a121: { a: number; [a120]: string; }[] = Iterator.zipKeyed({ a: [1], [a120 >Iterator.zipKeyed({ a: [1], [a120]: ["a"] }).toArray() : ({ a: number; [a120]: string; } & {})[] >Iterator.zipKeyed({ a: [1], [a120]: ["a"] }).toArray : () => ({ a: number; [a120]: string; } & {})[] >Iterator.zipKeyed({ a: [1], [a120]: ["a"] }) : IteratorObject<{ a: number; [a120]: string; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: [1], [a120]: ["a"] } : { a: number[]; [a120]: string[]; } >a : number[] >[1] : number[] @@ -1817,9 +1799,9 @@ const a122: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1] }, { mode: >Iterator.zipKeyed({ a: [1] }, { mode: "longest" }).toArray() : ({ a: number | undefined; } & {})[] >Iterator.zipKeyed({ a: [1] }, { mode: "longest" }).toArray : () => ({ a: number | undefined; } & {})[] >Iterator.zipKeyed({ a: [1] }, { mode: "longest" }) : IteratorObject<{ a: number | undefined; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: [1] } : { a: number[]; } >a : number[] >[1] : number[] @@ -1835,9 +1817,9 @@ const a123: { a: number; }[] = Iterator.zipKeyed({ a: [1] }, { mode: "longest", >Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray() : ({ a: number; } & {})[] >Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray : () => ({ a: number; } & {})[] >Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: 0 } }) : IteratorObject<{ a: number; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: [1] } : { a: number[]; } >a : number[] >[1] : number[] @@ -1859,9 +1841,9 @@ const a125 = Iterator.zipKeyed(a124).toArray(); >Iterator.zipKeyed(a124).toArray() : Record[] >Iterator.zipKeyed(a124).toArray : () => Record[] >Iterator.zipKeyed(a124) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a124 : object >toArray : () => Record[] @@ -1870,9 +1852,9 @@ const a126 = Iterator.zipKeyed(a124, { mode: "strict" }).toArray(); >Iterator.zipKeyed(a124, { mode: "strict" }).toArray() : Record[] >Iterator.zipKeyed(a124, { mode: "strict" }).toArray : () => Record[] >Iterator.zipKeyed(a124, { mode: "strict" }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a124 : object >{ mode: "strict" } : { mode: "strict"; } >mode : "strict" @@ -1884,9 +1866,9 @@ const a127 = Iterator.zipKeyed(a124, { mode: "longest" }).toArray(); >Iterator.zipKeyed(a124, { mode: "longest" }).toArray() : Record[] >Iterator.zipKeyed(a124, { mode: "longest" }).toArray : () => Record[] >Iterator.zipKeyed(a124, { mode: "longest" }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a124 : object >{ mode: "longest" } : { mode: "longest"; } >mode : "longest" @@ -1898,9 +1880,9 @@ const a128 = Iterator.zipKeyed(a124, { mode: "longest", padding: { a: 0 } }).toA >Iterator.zipKeyed(a124, { mode: "longest", padding: { a: 0 } }).toArray() : Record[] >Iterator.zipKeyed(a124, { mode: "longest", padding: { a: 0 } }).toArray : () => Record[] >Iterator.zipKeyed(a124, { mode: "longest", padding: { a: 0 } }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a124 : object >{ mode: "longest", padding: { a: 0 } } : { mode: "longest"; padding: { a: number; }; } >mode : "longest" @@ -1955,9 +1937,9 @@ const a135 = Iterator.zipKeyed(a134).toArray(); >Iterator.zipKeyed(a134).toArray() : Record[] >Iterator.zipKeyed(a134).toArray : () => Record[] >Iterator.zipKeyed(a134) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a134 : {} >toArray : () => Record[] @@ -1975,22 +1957,22 @@ const a137: never[] = a135; Iterator.zipKeyed(0); >Iterator.zipKeyed(0) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >0 : 0 Iterator.zipKeyed(null); >Iterator.zipKeyed(null) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } Iterator.zipKeyed(a107, { mode: "invalid" }); >Iterator.zipKeyed(a107, { mode: "invalid" }) : IteratorObject<{ a: number; b: never; f: never; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a107 : C1 >{ mode: "invalid" } : { mode: "invalid"; } >mode : "invalid" @@ -1998,9 +1980,9 @@ Iterator.zipKeyed(a107, { mode: "invalid" }); Iterator.zipKeyed(a107, { mode: "shortest", padding: {} }); >Iterator.zipKeyed(a107, { mode: "shortest", padding: {} }) : IteratorObject<{ a: number; b: never; f: never; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a107 : C1 >{ mode: "shortest", padding: {} } : { mode: "shortest"; padding: {}; } >mode : "shortest" @@ -2010,9 +1992,9 @@ Iterator.zipKeyed(a107, { mode: "shortest", padding: {} }); Iterator.zipKeyed(a107, { mode: "longest", padding: 0 }); >Iterator.zipKeyed(a107, { mode: "longest", padding: 0 }) : IteratorObject<{ a: number; b: never; f: never; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a107 : C1 >{ mode: "longest", padding: 0 } : { mode: "longest"; padding: number; } >mode : "longest" @@ -2020,20 +2002,872 @@ Iterator.zipKeyed(a107, { mode: "longest", padding: 0 }); >padding : number >0 : 0 -Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: "invalid" } }); ->Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: "invalid" } }) : IteratorObject<{ a: number; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a138: [number | boolean, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }).toArray(); +>a138 : [number | boolean, string | undefined][] +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }).toArray() : [1 | boolean, "a" | undefined][] +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }).toArray : () => [1 | boolean, "a" | undefined][] +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }) : IteratorObject<[1 | boolean, "a" | undefined], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->{ a: [1] } : { a: number[]; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] as const : [readonly [1], readonly ["a"]] +>[[1], ["a"]] : [readonly [1], readonly ["a"]] +>[1] : readonly [1] +>1 : 1 +>["a"] : readonly ["a"] +>"a" : "a" +>{ mode: "longest", padding: [true] } : { mode: "longest"; padding: [true]; } +>mode : "longest" +>"longest" : "longest" +>padding : [true] +>[true] : [true] +>true : true +>toArray : () => [1 | boolean, "a" | undefined][] + +const a139: { a: number | string; b: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: { a: "a" } }).toArray(); +>a139 : { a: number | string; b: number | undefined; }[] +>a : string | number +>b : number | undefined +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: { a: "a" } }).toArray() : ({ a: string | number; b: number | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: { a: "a" } }).toArray : () => ({ a: string | number; b: number | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: { a: "a" } }) : IteratorObject<{ a: string | number; b: number | undefined; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>{ a: [1], b: [2, 3] } : { a: number[]; b: number[]; } >a : number[] >[1] : number[] >1 : 1 ->{ mode: "longest", padding: { a: "invalid" } } : { mode: "longest"; padding: { a: string; }; } +>b : number[] +>[2, 3] : number[] +>2 : 2 +>3 : 3 +>{ mode: "longest", padding: { a: "a" } } : { mode: "longest"; padding: { a: string; }; } >mode : "longest" >"longest" : "longest" >padding : { a: string; } ->{ a: "invalid" } : { a: string; } +>{ a: "a" } : { a: string; } >a : string ->"invalid" : "invalid" +>"a" : "a" +>toArray : () => ({ a: string | number; b: number | undefined; } & {})[] + +declare const a140: boolean[]; +>a140 : boolean[] + +const a141: [number | boolean | undefined, string | boolean | undefined][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a140 }).toArray(); +>a141 : [number | boolean | undefined, string | boolean | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: a140 }).toArray() : [number | boolean | undefined, string | boolean | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: a140 }).toArray : () => [number | boolean | undefined, string | boolean | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: a140 }) : IteratorObject<[number | boolean | undefined, string | boolean | undefined], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] : [number[], string[]] +>[1] : number[] +>1 : 1 +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: a140 } : { mode: "longest"; padding: boolean[]; } +>mode : "longest" +>"longest" : "longest" +>padding : boolean[] +>a140 : boolean[] +>toArray : () => [number | boolean | undefined, string | boolean | undefined][] + +const a142 = Iterator.zip(a12, { mode: "longest", padding: new Set([false]) }).toArray(); +>a142 : (number | boolean | undefined)[][] +>Iterator.zip(a12, { mode: "longest", padding: new Set([false]) }).toArray() : (number | boolean | undefined)[][] +>Iterator.zip(a12, { mode: "longest", padding: new Set([false]) }).toArray : () => (number | boolean | undefined)[][] +>Iterator.zip(a12, { mode: "longest", padding: new Set([false]) }) : IteratorObject<(number | boolean | undefined)[], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>a12 : Iterable> +>{ mode: "longest", padding: new Set([false]) } : { mode: "longest"; padding: Set; } +>mode : "longest" +>"longest" : "longest" +>padding : Set +>new Set([false]) : Set +>Set : SetConstructor +>[false] : false[] +>false : false +>toArray : () => (number | boolean | undefined)[][] + +const a143: (number | boolean | undefined)[][] = a142; +>a143 : (number | boolean | undefined)[][] +>a142 : (number | boolean | undefined)[][] + +const a144: (number | undefined)[][] = a142; +>a144 : (number | undefined)[][] +>a142 : (number | boolean | undefined)[][] + +const a145: (number | boolean | undefined)[][] = Iterator.zip([[1], [2, 3]], { mode: "longest", padding: new Set([false]) }).toArray(); +>a145 : (number | boolean | undefined)[][] +>Iterator.zip([[1], [2, 3]], { mode: "longest", padding: new Set([false]) }).toArray() : (number | boolean | undefined)[][] +>Iterator.zip([[1], [2, 3]], { mode: "longest", padding: new Set([false]) }).toArray : () => (number | boolean | undefined)[][] +>Iterator.zip([[1], [2, 3]], { mode: "longest", padding: new Set([false]) }) : IteratorObject<(number | boolean | undefined)[], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], [2, 3]] : number[][] +>[1] : number[] +>1 : 1 +>[2, 3] : number[] +>2 : 2 +>3 : 3 +>{ mode: "longest", padding: new Set([false]) } : { mode: "longest"; padding: Set; } +>mode : "longest" +>"longest" : "longest" +>padding : Set +>new Set([false]) : Set +>Set : SetConstructor +>[false] : false[] +>false : false +>toArray : () => (number | boolean | undefined)[][] + +declare const a146: { a: boolean; } | { b: string; }; +>a146 : { a: boolean; } | { b: string; } +>a : boolean +>b : string + +const a147 = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a146 }).toArray(); +>a147 : ({ a: number | boolean | undefined; b: string | number | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a146 }).toArray() : ({ a: number | boolean | undefined; b: string | number | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a146 }).toArray : () => ({ a: number | boolean | undefined; b: string | number | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a146 }) : IteratorObject<{ a: number | boolean | undefined; b: string | number | undefined; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>{ a: [1], b: [2, 3] } : { a: number[]; b: number[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : number[] +>[2, 3] : number[] +>2 : 2 +>3 : 3 +>{ mode: "longest", padding: a146 } : { mode: "longest"; padding: { a: boolean; } | { b: string; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: boolean; } | { b: string; } +>a146 : { a: boolean; } | { b: string; } +>toArray : () => ({ a: number | boolean | undefined; b: string | number | undefined; } & {})[] + +const a148: { a: number | boolean | undefined; b: number | string | undefined; }[] = a147; +>a148 : { a: number | boolean | undefined; b: number | string | undefined; }[] +>a : number | boolean | undefined +>b : string | number | undefined +>a147 : ({ a: number | boolean | undefined; b: string | number | undefined; } & {})[] + +const a149: { a: number | undefined; b: number | undefined; }[] = a147; +>a149 : { a: number | undefined; b: number | undefined; }[] +>a : number | undefined +>b : number | undefined +>a147 : ({ a: number | boolean | undefined; b: string | number | undefined; } & {})[] + +declare const a150: [boolean] | [string, string]; +>a150 : [boolean] | [string, string] + +const a151: [number | boolean | string, number | string | undefined][] = Iterator.zip([[1], [2, 3]], { mode: "longest", padding: a150 }).toArray(); +>a151 : [string | number | boolean, string | number | undefined][] +>Iterator.zip([[1], [2, 3]], { mode: "longest", padding: a150 }).toArray() : [string | number | boolean, string | number | undefined][] +>Iterator.zip([[1], [2, 3]], { mode: "longest", padding: a150 }).toArray : () => [string | number | boolean, string | number | undefined][] +>Iterator.zip([[1], [2, 3]], { mode: "longest", padding: a150 }) : IteratorObject<[string | number | boolean, string | number | undefined], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], [2, 3]] : [number[], number[]] +>[1] : number[] +>1 : 1 +>[2, 3] : number[] +>2 : 2 +>3 : 3 +>{ mode: "longest", padding: a150 } : { mode: "longest"; padding: [boolean] | [string, string]; } +>mode : "longest" +>"longest" : "longest" +>padding : [boolean] | [string, string] +>a150 : [boolean] | [string, string] +>toArray : () => [string | number | boolean, string | number | undefined][] + +declare const a152: { mode: "longest"; padding?: { a: boolean; }; }; +>a152 : { mode: "longest"; padding?: { a: boolean; }; } +>mode : "longest" +>padding : { a: boolean; } | undefined +>a : boolean + +const a153 = Iterator.zipKeyed({ a: [1] }, a152).toArray(); +>a153 : ({ a: number | boolean | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1] }, a152).toArray() : ({ a: number | boolean | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1] }, a152).toArray : () => ({ a: number | boolean | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1] }, a152) : IteratorObject<{ a: number | boolean | undefined; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>{ a: [1] } : { a: number[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>a152 : { mode: "longest"; padding?: { a: boolean; }; } +>toArray : () => ({ a: number | boolean | undefined; } & {})[] + +const a154: { a: number | boolean | undefined; }[] = a153; +>a154 : { a: number | boolean | undefined; }[] +>a : number | boolean | undefined +>a153 : ({ a: number | boolean | undefined; } & {})[] + +const a155: { a: number | boolean; }[] = a153; +>a155 : { a: number | boolean; }[] +>a : number | boolean +>a153 : ({ a: number | boolean | undefined; } & {})[] + +declare const a156: { mode: "shortest"; } | { mode: "longest"; padding: [boolean]; } | undefined; +>a156 : { mode: "shortest"; } | { mode: "longest"; padding: [boolean]; } | undefined +>mode : "shortest" +>mode : "longest" +>padding : [boolean] + +const a157: [number | boolean | undefined][] = Iterator.zip([[1]], a156).toArray(); +>a157 : [number | boolean | undefined][] +>Iterator.zip([[1]], a156).toArray() : [number | boolean | undefined][] +>Iterator.zip([[1]], a156).toArray : () => [number | boolean | undefined][] +>Iterator.zip([[1]], a156) : IteratorObject<[number | boolean | undefined], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1]] : [number[]] +>[1] : number[] +>1 : 1 +>a156 : { mode: "shortest"; } | { mode: "longest"; padding: [boolean]; } | undefined +>toArray : () => [number | boolean | undefined][] + +const a158: [number][] = Iterator.zip([[1]], { mode: undefined }).toArray(); +>a158 : [number][] +>Iterator.zip([[1]], { mode: undefined }).toArray() : [number][] +>Iterator.zip([[1]], { mode: undefined }).toArray : () => [number][] +>Iterator.zip([[1]], { mode: undefined }) : IteratorObject<[number], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1]] : [number[]] +>[1] : number[] +>1 : 1 +>{ mode: undefined } : { mode: undefined; } +>mode : undefined +>undefined : undefined +>toArray : () => [number][] + +const a159: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: undefined }).toArray(); +>a159 : { a: number | undefined; }[] +>a : number | undefined +>Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: undefined }).toArray() : ({ a: number | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: undefined }).toArray : () => ({ a: number | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: undefined }) : IteratorObject<{ a: number | undefined; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>{ a: [1] } : { a: number[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>{ mode: "longest", padding: undefined } : { mode: "longest"; padding: undefined; } +>mode : "longest" +>"longest" : "longest" +>padding : undefined +>undefined : undefined +>toArray : () => ({ a: number | undefined; } & {})[] + +const a160: { a: number | { b: string; }; [a1]: boolean | string; }[] = Iterator.zipKeyed({ a: [1], [a1]: [true, false] }, { +>a160 : { a: number | { b: string; }; [a1]: boolean | string; }[] +>a : number | { b: string; } +>b : string +>[a1] : string | boolean +>a1 : unique symbol +>Iterator.zipKeyed({ a: [1], [a1]: [true, false] }, { mode: "longest", padding: { a: { b: "a" }, [a1]: "a" },}).toArray() : ({ a: number | { b: string; }; [a1]: string | boolean; } & {})[] +>Iterator.zipKeyed({ a: [1], [a1]: [true, false] }, { mode: "longest", padding: { a: { b: "a" }, [a1]: "a" },}).toArray : () => ({ a: number | { b: string; }; [a1]: string | boolean; } & {})[] +>Iterator.zipKeyed({ a: [1], [a1]: [true, false] }, { mode: "longest", padding: { a: { b: "a" }, [a1]: "a" },}) : IteratorObject<{ a: number | { b: string; }; [a1]: string | boolean; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>{ a: [1], [a1]: [true, false] } : { a: number[]; [a1]: boolean[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>[a1] : boolean[] +>a1 : unique symbol +>[true, false] : boolean[] +>true : true +>false : false +>{ mode: "longest", padding: { a: { b: "a" }, [a1]: "a" },} : { mode: "longest"; padding: { a: { b: string; }; [a1]: string; }; } + + mode: "longest", +>mode : "longest" +>"longest" : "longest" + + padding: { a: { b: "a" }, [a1]: "a" }, +>padding : { a: { b: string; }; [a1]: string; } +>{ a: { b: "a" }, [a1]: "a" } : { a: { b: string; }; [a1]: string; } +>a : { b: string; } +>{ b: "a" } : { b: string; } +>b : string +>"a" : "a" +>[a1] : string +>a1 : unique symbol +>"a" : "a" + +}).toArray(); +>toArray : () => ({ a: number | { b: string; }; [a1]: string | boolean; } & {})[] + +const a161: { "0": number | boolean; }[] = Iterator.zipKeyed({ "0": [1] }, { mode: "longest", padding: { 0: false } }).toArray(); +>a161 : { "0": number | boolean; }[] +>"0" : number | boolean +>Iterator.zipKeyed({ "0": [1] }, { mode: "longest", padding: { 0: false } }).toArray() : ({ "0": number | boolean; } & {})[] +>Iterator.zipKeyed({ "0": [1] }, { mode: "longest", padding: { 0: false } }).toArray : () => ({ "0": number | boolean; } & {})[] +>Iterator.zipKeyed({ "0": [1] }, { mode: "longest", padding: { 0: false } }) : IteratorObject<{ "0": number | boolean; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>{ "0": [1] } : { "0": number[]; } +>"0" : number[] +>[1] : number[] +>1 : 1 +>{ mode: "longest", padding: { 0: false } } : { mode: "longest"; padding: { 0: false; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { 0: false; } +>{ 0: false } : { 0: false; } +>0 : false +>false : false +>toArray : () => ({ "0": number | boolean; } & {})[] + +const a162: { 0: number | boolean; }[] = Iterator.zipKeyed({ 0: [1] }, { mode: "longest", padding: { "0": false } }).toArray(); +>a162 : { 0: number | boolean; }[] +>0 : number | boolean +>Iterator.zipKeyed({ 0: [1] }, { mode: "longest", padding: { "0": false } }).toArray() : ({ 0: number | boolean; } & {})[] +>Iterator.zipKeyed({ 0: [1] }, { mode: "longest", padding: { "0": false } }).toArray : () => ({ 0: number | boolean; } & {})[] +>Iterator.zipKeyed({ 0: [1] }, { mode: "longest", padding: { "0": false } }) : IteratorObject<{ 0: number | boolean; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>{ 0: [1] } : { 0: number[]; } +>0 : number[] +>[1] : number[] +>1 : 1 +>{ mode: "longest", padding: { "0": false } } : { mode: "longest"; padding: { "0": false; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { "0": false; } +>{ "0": false } : { "0": false; } +>"0" : false +>false : false +>toArray : () => ({ 0: number | boolean; } & {})[] + +const a163 = Iterator.zipKeyed({ 0: [1] }, { mode: "longest", padding: { "01": false } }).toArray(); +>a163 : ({ 0: number | undefined; } & {})[] +>Iterator.zipKeyed({ 0: [1] }, { mode: "longest", padding: { "01": false } }).toArray() : ({ 0: number | undefined; } & {})[] +>Iterator.zipKeyed({ 0: [1] }, { mode: "longest", padding: { "01": false } }).toArray : () => ({ 0: number | undefined; } & {})[] +>Iterator.zipKeyed({ 0: [1] }, { mode: "longest", padding: { "01": false } }) : IteratorObject<{ 0: number | undefined; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>{ 0: [1] } : { 0: number[]; } +>0 : number[] +>[1] : number[] +>1 : 1 +>{ mode: "longest", padding: { "01": false } } : { mode: "longest"; padding: { "01": false; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { "01": false; } +>{ "01": false } : { "01": false; } +>"01" : false +>false : false +>toArray : () => ({ 0: number | undefined; } & {})[] + +const a164: { 0: number | undefined; }[] = a163; +>a164 : { 0: number | undefined; }[] +>0 : number | undefined +>a163 : ({ 0: number | undefined; } & {})[] + +const a165: { 0: number; }[] = a163; +>a165 : { 0: number; }[] +>0 : number +>a163 : ({ 0: number | undefined; } & {})[] + +declare const a166: Record; +>a166 : Record + +const a167 = Iterator.zipKeyed({ NaN: [1], Infinity: [2], "-Infinity": [3] }, { mode: "longest", padding: a166 }).toArray(); +>a167 : ({ NaN: number | boolean | undefined; Infinity: number | boolean | undefined; "-Infinity": number | boolean | undefined; } & {})[] +>Iterator.zipKeyed({ NaN: [1], Infinity: [2], "-Infinity": [3] }, { mode: "longest", padding: a166 }).toArray() : ({ NaN: number | boolean | undefined; Infinity: number | boolean | undefined; "-Infinity": number | boolean | undefined; } & {})[] +>Iterator.zipKeyed({ NaN: [1], Infinity: [2], "-Infinity": [3] }, { mode: "longest", padding: a166 }).toArray : () => ({ NaN: number | boolean | undefined; Infinity: number | boolean | undefined; "-Infinity": number | boolean | undefined; } & {})[] +>Iterator.zipKeyed({ NaN: [1], Infinity: [2], "-Infinity": [3] }, { mode: "longest", padding: a166 }) : IteratorObject<{ NaN: number | boolean | undefined; Infinity: number | boolean | undefined; "-Infinity": number | boolean | undefined; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>{ NaN: [1], Infinity: [2], "-Infinity": [3] } : { NaN: number[]; Infinity: number[]; "-Infinity": number[]; } +>NaN : number[] +>[1] : number[] +>1 : 1 +>Infinity : number[] +>[2] : number[] +>2 : 2 +>"-Infinity" : number[] +>[3] : number[] +>3 : 3 +>{ mode: "longest", padding: a166 } : { mode: "longest"; padding: Record; } +>mode : "longest" +>"longest" : "longest" +>padding : Record +>a166 : Record +>toArray : () => ({ NaN: number | boolean | undefined; Infinity: number | boolean | undefined; "-Infinity": number | boolean | undefined; } & {})[] + +const a168: { NaN: number | boolean | undefined; Infinity: number | boolean | undefined; "-Infinity": number | boolean | undefined; }[] = a167; +>a168 : { NaN: number | boolean | undefined; Infinity: number | boolean | undefined; "-Infinity": number | boolean | undefined; }[] +>NaN : number | boolean | undefined +>Infinity : number | boolean | undefined +>"-Infinity" : number | boolean | undefined +>a167 : ({ NaN: number | boolean | undefined; Infinity: number | boolean | undefined; "-Infinity": number | boolean | undefined; } & {})[] + +const a169: { NaN: number | undefined; Infinity: number | undefined; "-Infinity": number | undefined; }[] = a167; +>a169 : { NaN: number | undefined; Infinity: number | undefined; "-Infinity": number | undefined; }[] +>NaN : number | undefined +>Infinity : number | undefined +>"-Infinity" : number | undefined +>a167 : ({ NaN: number | boolean | undefined; Infinity: number | boolean | undefined; "-Infinity": number | boolean | undefined; } & {})[] + +const a170 = Iterator.zipKeyed(a58, { mode: "longest", padding: { a: false } }).toArray(); +>a170 : ({ [x: string]: number | boolean | undefined; } & {})[] +>Iterator.zipKeyed(a58, { mode: "longest", padding: { a: false } }).toArray() : ({ [x: string]: number | boolean | undefined; } & {})[] +>Iterator.zipKeyed(a58, { mode: "longest", padding: { a: false } }).toArray : () => ({ [x: string]: number | boolean | undefined; } & {})[] +>Iterator.zipKeyed(a58, { mode: "longest", padding: { a: false } }) : IteratorObject<{ [x: string]: number | boolean | undefined; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>a58 : Record> +>{ mode: "longest", padding: { a: false } } : { mode: "longest"; padding: { a: false; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: false; } +>{ a: false } : { a: false; } +>a : false +>false : false +>toArray : () => ({ [x: string]: number | boolean | undefined; } & {})[] + +const a171: Record[] = a170; +>a171 : Record[] +>a170 : ({ [x: string]: number | boolean | undefined; } & {})[] + +const a172: Record[] = a170; +>a172 : Record[] +>a170 : ({ [x: string]: number | boolean | undefined; } & {})[] + +const a173: [number | undefined, string | undefined][] = Iterator.zip<[Iterable, Iterable]>([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); +>a173 : [number | undefined, string | undefined][] +>Iterator.zip<[Iterable, Iterable]>([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray() : [number | undefined, string | undefined][] +>Iterator.zip<[Iterable, Iterable]>([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray : () => [number | undefined, string | undefined][] +>Iterator.zip<[Iterable, Iterable]>([[1], ["a"]], { mode: "longest", padding: [0, ""] }) : IteratorObject<[number | undefined, string | undefined], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] : [number[], string[]] +>[1] : number[] +>1 : 1 +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: [0, ""] } : { mode: "longest"; padding: [number, string]; } +>mode : "longest" +>"longest" : "longest" +>padding : [number, string] +>[0, ""] : [number, string] +>0 : 0 +>"" : "" +>toArray : () => [number | undefined, string | undefined][] + +const a174: (number | undefined)[][] = Iterator.zip>(a12, { mode: "longest", padding: [0] }).toArray(); +>a174 : (number | undefined)[][] +>Iterator.zip>(a12, { mode: "longest", padding: [0] }).toArray() : (number | undefined)[][] +>Iterator.zip>(a12, { mode: "longest", padding: [0] }).toArray : () => (number | undefined)[][] +>Iterator.zip>(a12, { mode: "longest", padding: [0] }) : IteratorObject<(number | undefined)[], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>a12 : Iterable> +>{ mode: "longest", padding: [0] } : { mode: "longest"; padding: number[]; } +>mode : "longest" +>"longest" : "longest" +>padding : number[] +>[0] : number[] +>0 : 0 +>toArray : () => (number | undefined)[][] + +const a175: { a: number | undefined; }[] = Iterator.zipKeyed<{ a: Iterable; }>({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray(); +>a175 : { a: number | undefined; }[] +>a : number | undefined +>Iterator.zipKeyed<{ a: Iterable; }>({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray() : ({ a: number | undefined; } & {})[] +>Iterator.zipKeyed<{ a: Iterable; }>({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray : () => ({ a: number | undefined; } & {})[] +>Iterator.zipKeyed<{ a: Iterable; }>({ a: [1] }, { mode: "longest", padding: { a: 0 } }) : IteratorObject<{ a: number | undefined; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>a : Iterable +>{ a: [1] } : { a: number[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>{ mode: "longest", padding: { a: 0 } } : { mode: "longest"; padding: { a: number; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: number; } +>{ a: 0 } : { a: number; } +>a : number +>0 : 0 +>toArray : () => ({ a: number | undefined; } & {})[] + +const a176: [number | boolean][] = Iterator.zip<[Iterable], [boolean]>([[1]], { mode: "longest", padding: [false] }).toArray(); +>a176 : [number | boolean][] +>Iterator.zip<[Iterable], [boolean]>([[1]], { mode: "longest", padding: [false] }).toArray() : [number | boolean][] +>Iterator.zip<[Iterable], [boolean]>([[1]], { mode: "longest", padding: [false] }).toArray : () => [number | boolean][] +>Iterator.zip<[Iterable], [boolean]>([[1]], { mode: "longest", padding: [false] }) : IteratorObject<[number | boolean], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1]] : [number[]] +>[1] : number[] +>1 : 1 +>{ mode: "longest", padding: [false] } : { mode: "longest"; padding: [false]; } +>mode : "longest" +>"longest" : "longest" +>padding : [false] +>[false] : [false] +>false : false +>toArray : () => [number | boolean][] + +const a177: { a: number | boolean; }[] = Iterator.zipKeyed<{ a: Iterable; }, { a: boolean; }>({ a: [1] }, { mode: "longest", padding: { a: false } }).toArray(); +>a177 : { a: number | boolean; }[] +>a : number | boolean +>Iterator.zipKeyed<{ a: Iterable; }, { a: boolean; }>({ a: [1] }, { mode: "longest", padding: { a: false } }).toArray() : ({ a: number | boolean; } & {})[] +>Iterator.zipKeyed<{ a: Iterable; }, { a: boolean; }>({ a: [1] }, { mode: "longest", padding: { a: false } }).toArray : () => ({ a: number | boolean; } & {})[] +>Iterator.zipKeyed<{ a: Iterable; }, { a: boolean; }>({ a: [1] }, { mode: "longest", padding: { a: false } }) : IteratorObject<{ a: number | boolean; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>a : Iterable +>a : boolean +>{ a: [1] } : { a: number[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>{ mode: "longest", padding: { a: false } } : { mode: "longest"; padding: { a: false; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: false; } +>{ a: false } : { a: false; } +>a : false +>false : false +>toArray : () => ({ a: number | boolean; } & {})[] + +Iterator.zipKeyed<{ a: Iterable; }>({ a: [1] }, { mode: "longest", padding: 0 }); +>Iterator.zipKeyed<{ a: Iterable; }>({ a: [1] }, { mode: "longest", padding: 0 }) : IteratorObject<{ a: number; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>a : Iterable +>{ a: [1] } : { a: number[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>{ mode: "longest", padding: 0 } : { mode: "longest"; padding: number; } +>mode : "longest" +>"longest" : "longest" +>padding : number +>0 : 0 + +Iterator.zipKeyed<{}>({}, { mode: "longest", padding: 0 }); +>Iterator.zipKeyed<{}>({}, { mode: "longest", padding: 0 }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>{} : {} +>{ mode: "longest", padding: 0 } : { mode: "longest"; padding: number; } +>mode : "longest" +>"longest" : "longest" +>padding : number +>0 : 0 + +Iterator.zipKeyed<{ a: Iterable; }, {}>({ a: [1] }, { mode: "longest", padding: 0 }); +>Iterator.zipKeyed<{ a: Iterable; }, {}>({ a: [1] }, { mode: "longest", padding: 0 }) : IteratorObject<{ a: number; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>a : Iterable +>{ a: [1] } : { a: number[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>{ mode: "longest", padding: 0 } : { mode: "longest"; padding: number; } +>mode : "longest" +>"longest" : "longest" +>padding : number +>0 : 0 + +=== b.ts === +export function f1>>(a: T) { +>f1 : >>(a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown> +>a : T + + return Iterator.zipKeyed(a); +>Iterator.zipKeyed(a) : IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>a : T +} + +export function f2>>(a: T) { +>f2 : >>(a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> extends infer T_2 ? T_2 extends Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> as {} extends Pick | Iterator) & object ? U : never : never : never) | undefined; }>, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> extends infer T_2 ? T_2 extends Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> as {} extends Pick | Iterator) & object ? U : never : never : never) | undefined; }>, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown> +>a : T + + return Iterator.zipKeyed(a, { mode: "longest" }); +>Iterator.zipKeyed(a, { mode: "longest" }) : IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> extends infer T_2 ? T_2 extends Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> as {} extends Pick | Iterator) & object ? U : never : never : never) | undefined; }>, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> extends infer T_2 ? T_2 extends Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> as {} extends Pick | Iterator) & object ? U : never : never : never) | undefined; }>, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>a : T +>{ mode: "longest" } : { mode: "longest"; } +>mode : "longest" +>"longest" : "longest" +} + +export function f3>>(a: T) { +>f3 : >>(a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : undefined)) | undefined; }, undefined, unknown> +>a : T + + return Iterator.zipKeyed(a, { mode: "longest", padding: {} }); +>Iterator.zipKeyed(a, { mode: "longest", padding: {} }) : IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : undefined)) | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>a : T +>{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } +>mode : "longest" +>"longest" : "longest" +>padding : {} +>{} : {} +} + +export function f4(a: T) { +>f4 : (a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown> +>a : T + + return Iterator.zipKeyed(a); +>Iterator.zipKeyed(a) : IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>a : T +} + +export function f5(a: Iterable, b: U) { +>f5 : (a: Iterable, b: U) => IteratorObject<{ a: T | U; } & {}, undefined, unknown> +>a : Iterable +>b : U + + return Iterator.zipKeyed({ a }, { mode: "longest", padding: { a: b } }); +>Iterator.zipKeyed({ a }, { mode: "longest", padding: { a: b } }) : IteratorObject<{ a: T | U; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U_1 : never : never : never) | undefined; }>(iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U_1 : never : never : never) | undefined; }>(iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>{ a } : { a: Iterable; } +>a : Iterable +>{ mode: "longest", padding: { a: b } } : { mode: "longest"; padding: { a: U; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: U; } +>{ a: b } : { a: U; } +>a : U +>b : U +} + +export function f6 | Iterator)[]>(a: T) { +>f6 : | Iterator)[]>(a: T) => IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown> +>a : T + + return Iterator.zip(a); +>Iterator.zip(a) : IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T_1, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T_1, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T_1, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T_1 extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T_1 extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T_1 extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T_1, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T_1, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T_1, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T_1 extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T_1 extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T_1 extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>a : T +} + +export function f7(a: Iterable, b: U) { +>f7 : (a: Iterable, b: U) => IteratorObject<{ a: T | (U extends unknown ? U["a" & keyof U] : never) | ("a" extends keyof { [K in keyof U as {} extends Pick ? never : K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K]: unknown; } ? never : undefined); } & {}, undefined, unknown> +>a : Iterable +>b : U + + return Iterator.zipKeyed({ a }, { mode: "longest", padding: b }); +>Iterator.zipKeyed({ a }, { mode: "longest", padding: b }) : IteratorObject<{ a: T | (U extends unknown ? U["a" & keyof U] : never) | ("a" extends keyof { [K in keyof U as {} extends Pick ? never : K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K]: unknown; } ? never : undefined); } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U_1 : never : never : never) | undefined; }>(iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U_1 : never : never : never) | undefined; }>(iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>{ a } : { a: Iterable; } +>a : Iterable +>{ mode: "longest", padding: b } : { mode: "longest"; padding: U; } +>mode : "longest" +>"longest" : "longest" +>padding : U +>b : U +} + +export const a = f1({ a: [1], b: ["a"] }).toArray(); +>a : ({ a: number; b: string; } & {})[] +>f1({ a: [1], b: ["a"] }).toArray() : ({ a: number; b: string; } & {})[] +>f1({ a: [1], b: ["a"] }).toArray : () => ({ a: number; b: string; } & {})[] +>f1({ a: [1], b: ["a"] }) : IteratorObject<{ a: number; b: string; } & {}, undefined, unknown> +>f1 : >>(a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown> +>{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : string[] +>["a"] : string[] +>"a" : "a" +>toArray : () => ({ a: number; b: string; } & {})[] + +export const b = f2({ a: [1], b: ["a"] }).toArray(); +>b : ({ a: number | undefined; b: string | undefined; } & {})[] +>f2({ a: [1], b: ["a"] }).toArray() : ({ a: number | undefined; b: string | undefined; } & {})[] +>f2({ a: [1], b: ["a"] }).toArray : () => ({ a: number | undefined; b: string | undefined; } & {})[] +>f2({ a: [1], b: ["a"] }) : IteratorObject<{ a: number | undefined; b: string | undefined; } & {}, undefined, unknown> +>f2 : >>(a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> extends infer T_2 ? T_2 extends Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> as {} extends Pick | Iterator) & object ? U : never : never : never) | undefined; }>, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> extends infer T_2 ? T_2 extends Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> as {} extends Pick | Iterator) & object ? U : never : never : never) | undefined; }>, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown> +>{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : string[] +>["a"] : string[] +>"a" : "a" +>toArray : () => ({ a: number | undefined; b: string | undefined; } & {})[] + +export const c = f3({ a: [1], b: ["a"] }).toArray(); +>c : ({ a: number | undefined; b: string | undefined; } & {})[] +>f3({ a: [1], b: ["a"] }).toArray() : ({ a: number | undefined; b: string | undefined; } & {})[] +>f3({ a: [1], b: ["a"] }).toArray : () => ({ a: number | undefined; b: string | undefined; } & {})[] +>f3({ a: [1], b: ["a"] }) : IteratorObject<{ a: number | undefined; b: string | undefined; } & {}, undefined, unknown> +>f3 : >>(a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : undefined)) | undefined; }, undefined, unknown> +>{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : string[] +>["a"] : string[] +>"a" : "a" +>toArray : () => ({ a: number | undefined; b: string | undefined; } & {})[] + +export const d = f4({ a: [1], b: ["a"] }).toArray(); +>d : ({ a: number; b: string; } & {})[] +>f4({ a: [1], b: ["a"] }).toArray() : ({ a: number; b: string; } & {})[] +>f4({ a: [1], b: ["a"] }).toArray : () => ({ a: number; b: string; } & {})[] +>f4({ a: [1], b: ["a"] }) : IteratorObject<{ a: number; b: string; } & {}, undefined, unknown> +>f4 : (a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown> +>{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : string[] +>["a"] : string[] +>"a" : "a" +>toArray : () => ({ a: number; b: string; } & {})[] + +export const e = f5([1], false).toArray(); +>e : ({ a: number | boolean; } & {})[] +>f5([1], false).toArray() : ({ a: number | boolean; } & {})[] +>f5([1], false).toArray : () => ({ a: number | boolean; } & {})[] +>f5([1], false) : IteratorObject<{ a: number | boolean; } & {}, undefined, unknown> +>f5 : (a: Iterable, b: U) => IteratorObject<{ a: T | U; } & {}, undefined, unknown> +>[1] : number[] +>1 : 1 +>false : false +>toArray : () => ({ a: number | boolean; } & {})[] + +export const f = f6([[1], ["a"]] as const).toArray(); +>f : [1, "a"][] +>f6([[1], ["a"]] as const).toArray() : [1, "a"][] +>f6([[1], ["a"]] as const).toArray : () => [1, "a"][] +>f6([[1], ["a"]] as const) : IteratorObject<[1, "a"], undefined, unknown> +>f6 : | Iterator)[]>(a: T) => IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown> +>[[1], ["a"]] as const : readonly [readonly [1], readonly ["a"]] +>[[1], ["a"]] : readonly [readonly [1], readonly ["a"]] +>[1] : readonly [1] +>1 : 1 +>["a"] : readonly ["a"] +>"a" : "a" +>toArray : () => [1, "a"][] + +export const g = f7([1], { a: false }).toArray(); +>g : ({ a: number | boolean; } & {})[] +>f7([1], { a: false }).toArray() : ({ a: number | boolean; } & {})[] +>f7([1], { a: false }).toArray : () => ({ a: number | boolean; } & {})[] +>f7([1], { a: false }) : IteratorObject<{ a: number | boolean; } & {}, undefined, unknown> +>f7 : (a: Iterable, b: U) => IteratorObject<{ a: T | (U extends unknown ? U["a" & keyof U] : never) | ("a" extends keyof { [K in keyof U as {} extends Pick ? never : K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K]: unknown; } ? never : undefined); } & {}, undefined, unknown> +>[1] : number[] +>1 : 1 +>{ a: false } : { a: false; } +>a : false +>false : false +>toArray : () => ({ a: number | boolean; } & {})[] + +export const h = Iterator.zip; +>h : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } + +export const i = Iterator.zipKeyed; +>i : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } + +export const j = h([[1], ["a"]], { mode: "longest", padding: [false, false] }).toArray(); +>j : [number | boolean, string | boolean][] +>h([[1], ["a"]], { mode: "longest", padding: [false, false] }).toArray() : [number | boolean, string | boolean][] +>h([[1], ["a"]], { mode: "longest", padding: [false, false] }).toArray : () => [number | boolean, string | boolean][] +>h([[1], ["a"]], { mode: "longest", padding: [false, false] }) : IteratorObject<[number | boolean, string | boolean], undefined, unknown> +>h : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] : [number[], string[]] +>[1] : number[] +>1 : 1 +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: [false, false] } : { mode: "longest"; padding: [false, false]; } +>mode : "longest" +>"longest" : "longest" +>padding : [false, false] +>[false, false] : [false, false] +>false : false +>false : false +>toArray : () => [number | boolean, string | boolean][] + +export const k = i({ a: [1], b: [2, 3] }, { mode: "longest", padding: { a: false } }).toArray(); +>k : ({ a: number | boolean; b: number | undefined; } & {})[] +>i({ a: [1], b: [2, 3] }, { mode: "longest", padding: { a: false } }).toArray() : ({ a: number | boolean; b: number | undefined; } & {})[] +>i({ a: [1], b: [2, 3] }, { mode: "longest", padding: { a: false } }).toArray : () => ({ a: number | boolean; b: number | undefined; } & {})[] +>i({ a: [1], b: [2, 3] }, { mode: "longest", padding: { a: false } }) : IteratorObject<{ a: number | boolean; b: number | undefined; } & {}, undefined, unknown> +>i : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>{ a: [1], b: [2, 3] } : { a: number[]; b: number[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : number[] +>[2, 3] : number[] +>2 : 2 +>3 : 3 +>{ mode: "longest", padding: { a: false } } : { mode: "longest"; padding: { a: false; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: false; } +>{ a: false } : { a: false; } +>a : false +>false : false +>toArray : () => ({ a: number | boolean; b: number | undefined; } & {})[] diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).errors.txt b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).errors.txt index c2e81cfcba57c..f54e2fa04b30f 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).errors.txt @@ -1,27 +1,18 @@ -iteratorZip.ts(62,23): error TS2769: No overload matches this call. +a.ts(62,23): error TS2769: No overload matches this call. The last overload gave the following error. - Type '"invalid"' is not assignable to type '"longest" | "shortest" | "strict"'. -iteratorZip.ts(64,56): error TS2769: No overload matches this call. - The last overload gave the following error. - Type 'true[]' is not assignable to type 'Iterable<"a" | 1 | undefined> & object'. - Type 'true[]' is not assignable to type 'Iterable<"a" | 1 | undefined>'. - The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. - Type 'IteratorResult' is not assignable to type 'IteratorResult<"a" | 1 | undefined, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. - Type 'IteratorYieldResult' is not assignable to type 'IteratorResult<"a" | 1 | undefined, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. - Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult<"a" | 1 | undefined>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. - Type 'true' is not assignable to type '"a" | 1 | undefined'. -iteratorZip.ts(66,41): error TS2769: No overload matches this call. + Type '"invalid"' is not assignable to type '"longest" | "shortest" | "strict" | undefined'. +a.ts(64,41): error TS2769: No overload matches this call. The last overload gave the following error. Object literal may only specify known properties, and 'padding' does not exist in type 'IteratorZipShortestOptions'. -iteratorZip.ts(68,14): error TS2769: No overload matches this call. +a.ts(66,14): error TS2769: No overload matches this call. The last overload gave the following error. Argument of type 'number' is not assignable to parameter of type 'Iterable> & object'. Type 'number' is not assignable to type 'Iterable>'. -iteratorZip.ts(78,14): error TS2769: No overload matches this call. +a.ts(76,14): error TS2769: No overload matches this call. The last overload gave the following error. Argument of type 'string' is not assignable to parameter of type 'Iterable> & object'. Type 'string' is not assignable to type 'Iterable>'. -iteratorZip.ts(79,14): error TS2769: No overload matches this call. +a.ts(77,14): error TS2769: No overload matches this call. The last overload gave the following error. Argument of type 'string[]' is not assignable to parameter of type 'Iterable> & object'. Type 'string[]' is not assignable to type 'Iterable>'. @@ -30,7 +21,7 @@ iteratorZip.ts(79,14): error TS2769: No overload matches this call. Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. Type 'string' is not assignable to type 'IteratorInput'. -iteratorZip.ts(80,14): error TS2769: No overload matches this call. +a.ts(78,14): error TS2769: No overload matches this call. The last overload gave the following error. Argument of type 'Set' is not assignable to parameter of type 'Iterable> & object'. Type 'Set' is not assignable to type 'Iterable>'. @@ -39,26 +30,26 @@ iteratorZip.ts(80,14): error TS2769: No overload matches this call. Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. Type 'string' is not assignable to type 'IteratorInput'. -iteratorZip.ts(81,19): error TS2769: No overload matches this call. +a.ts(79,19): error TS2769: No overload matches this call. The last overload gave the following error. Argument of type '"ab"' is not assignable to parameter of type 'never'. -iteratorZip.ts(83,37): error TS2769: No overload matches this call. +a.ts(81,37): error TS2769: No overload matches this call. The last overload gave the following error. - Type 'string' is not assignable to type 'Iterable & object'. - Type 'string' is not assignable to type 'Iterable'. -iteratorZip.ts(84,42): error TS2769: No overload matches this call. + Type 'string' is not assignable to type 'Iterable & object'. + Type 'string' is not assignable to type 'object'. +a.ts(82,42): error TS2769: No overload matches this call. The last overload gave the following error. - Type 'string' is not assignable to type 'Iterable & object'. + Type 'string' is not assignable to type 'Iterable & object'. Type 'string' is not assignable to type 'object'. -iteratorZip.ts(85,19): error TS2769: No overload matches this call. +a.ts(83,19): error TS2769: No overload matches this call. The last overload gave the following error. Argument of type '{}' is not assignable to parameter of type 'never'. -iteratorZip.ts(93,8): error TS2339: Property 'b' does not exist on type '{ a: number; } & {}'. -iteratorZip.ts(109,8): error TS2339: Property 'd' does not exist on type '{ a: number; } & { b?: string; c?: IteratorZipValue | undefined, "c", never, {}>; }'. -iteratorZip.ts(110,7): error TS2322: Type '({ a: number; } & { b?: string; c?: IteratorZipValue | undefined, "c", never, {}>; })[]' is not assignable to type '{ a: number; c: boolean; }[]'. +a.ts(91,8): error TS2339: Property 'b' does not exist on type '{ a: number; } & {}'. +a.ts(107,8): error TS2339: Property 'd' does not exist on type '{ a: number; } & { b?: string; c?: IteratorZipValue | undefined, "c", never, {}>; }'. +a.ts(108,7): error TS2322: Type '({ a: number; } & { b?: string; c?: IteratorZipValue | undefined, "c", never, {}>; })[]' is not assignable to type '{ a: number; c: boolean; }[]'. Type '{ a: number; } & { b?: string; c?: IteratorZipValue | undefined, "c", never, {}>; }' is not assignable to type '{ a: number; c: boolean; }'. Property 'c' is optional in type '{ a: number; } & { b?: string; c?: IteratorZipValue | undefined, "c", never, {}>; }' but required in type '{ a: number; c: boolean; }'. -iteratorZip.ts(130,14): error TS2769: No overload matches this call. +a.ts(128,14): error TS2769: No overload matches this call. The last overload gave the following error. Argument of type 'undefined[]' is not assignable to parameter of type 'Iterable> & object'. Type 'undefined[]' is not assignable to type 'Iterable>'. @@ -67,99 +58,134 @@ iteratorZip.ts(130,14): error TS2769: No overload matches this call. Type 'IteratorYieldResult' is not assignable to type 'IteratorResult, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. Type 'undefined' is not assignable to type 'IteratorInput'. -iteratorZip.ts(146,7): error TS2322: Type '[number, ...IteratorZipValue, number, undefined, [number]>[]][]' is not assignable to type 'number[][]'. +a.ts(144,7): error TS2322: Type '[number, ...IteratorZipValue, number, undefined, [number]>[]][]' is not assignable to type 'number[][]'. Type '[number, ...IteratorZipValue, number, undefined, [number]>[]]' is not assignable to type 'number[]'. Type 'IteratorZipValue, number, undefined, [number]>' is not assignable to type 'number'. Type 'undefined' is not assignable to type 'number'. -iteratorZip.ts(151,7): error TS2322: Type '({ [x: string]: IteratorZipValue, string, undefined, {}>; } & {})[]' is not assignable to type 'Record[]'. +a.ts(149,7): error TS2322: Type '({ [x: string]: IteratorZipValue, string, undefined, {}>; } & {})[]' is not assignable to type 'Record[]'. Type '{ [x: string]: IteratorZipValue, string, undefined, {}>; } & {}' is not assignable to type 'Record'. 'string' index signatures are incompatible. Type 'IteratorZipValue, string, undefined, {}>' is not assignable to type 'number'. Type 'undefined' is not assignable to type 'number'. -iteratorZip.ts(156,7): error TS2322: Type '({ a: IteratorZipValue>; b: IteratorZipValue>; } & {})[]' is not assignable to type '{ a: number; b: number; }[]'. +a.ts(154,7): error TS2322: Type '({ a: IteratorZipValue>; b: IteratorZipValue>; } & {})[]' is not assignable to type '{ a: number; b: number; }[]'. Type '{ a: IteratorZipValue>; b: IteratorZipValue>; } & {}' is not assignable to type '{ a: number; b: number; }'. Types of property 'a' are incompatible. Type 'IteratorZipValue>' is not assignable to type 'number'. Type 'undefined' is not assignable to type 'number'. -iteratorZip.ts(165,7): error TS2322: Type '[number, IteratorZipValue][]' is not assignable to type '[number, string][]'. +a.ts(163,7): error TS2322: Type '[number, IteratorZipValue][]' is not assignable to type '[number, string][]'. Type '[number, IteratorZipValue]' is not assignable to type '[number, string]'. Type at position 1 in source is not compatible with type at position 1 in target. Type 'IteratorZipValue' is not assignable to type 'string'. Type 'undefined' is not assignable to type 'string'. -iteratorZip.ts(168,7): error TS2322: Type '({ a: number; b: IteratorZipValue; } & {})[]' is not assignable to type '{ a: number; b: string; }[]'. +a.ts(166,7): error TS2322: Type '({ a: number; b: IteratorZipValue; } & {})[]' is not assignable to type '{ a: number; b: string; }[]'. Type '{ a: number; b: IteratorZipValue; } & {}' is not assignable to type '{ a: number; b: string; }'. Types of property 'b' are incompatible. Type 'IteratorZipValue' is not assignable to type 'string'. Type 'undefined' is not assignable to type 'string'. -iteratorZip.ts(174,7): error TS2322: Type '[number, IteratorZipValue][]' is not assignable to type '[number, string][]'. +a.ts(172,7): error TS2322: Type '[number, IteratorZipValue][]' is not assignable to type '[number, string][]'. Type '[number, IteratorZipValue]' is not assignable to type '[number, string]'. Type at position 1 in source is not compatible with type at position 1 in target. Type 'IteratorZipValue' is not assignable to type 'string'. Type 'undefined' is not assignable to type 'string'. -iteratorZip.ts(178,7): error TS2322: Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>[]' is not assignable to type 'number[][]'. +a.ts(176,7): error TS2322: Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>[]' is not assignable to type 'number[][]'. Type 'IteratorZipResult<[Iterable] | [Iterable, Iterable], undefined, [number]>' is not assignable to type 'number[]'. Type '[number, IteratorZipValue, "1", undefined, [number]>]' is not assignable to type 'number[]'. Type 'IteratorZipValue, "1", undefined, [number]>' is not assignable to type 'number'. Type 'undefined' is not assignable to type 'number'. -iteratorZip.ts(181,7): error TS2322: Type '(({ a: number; } & {}) | ({ b: IteratorZipValue, "b", undefined, { a: number; }>; } & {}))[]' is not assignable to type '({ a: number; } | { b: string; })[]'. +a.ts(179,7): error TS2322: Type '(({ a: number; } & {}) | ({ b: IteratorZipValue, "b", undefined, { a: number; }>; } & {}))[]' is not assignable to type '({ a: number; } | { b: string; })[]'. Type '({ a: number; } & {}) | ({ b: IteratorZipValue, "b", undefined, { a: number; }>; } & {})' is not assignable to type '{ a: number; } | { b: string; }'. Type '{ b: IteratorZipValue, "b", undefined, { a: number; }>; } & {}' is not assignable to type '{ a: number; } | { b: string; }'. Type '{ b: IteratorZipValue, "b", undefined, { a: number; }>; } & {}' is not assignable to type '{ b: string; }'. Types of property 'b' are incompatible. Type 'IteratorZipValue, "b", undefined, { a: number; }>' is not assignable to type 'string'. Type 'undefined' is not assignable to type 'string'. -iteratorZip.ts(185,7): error TS2322: Type '({ a: IteratorZipValue; b: IteratorZipValue; } & {})[]' is not assignable to type '{ a: number; b: string; }[]'. +a.ts(183,7): error TS2322: Type '({ a: IteratorZipValue; b: IteratorZipValue; } & {})[]' is not assignable to type '{ a: number; b: string; }[]'. Type '{ a: IteratorZipValue; b: IteratorZipValue; } & {}' is not assignable to type '{ a: number; b: string; }'. Types of property 'a' are incompatible. Type 'IteratorZipValue' is not assignable to type 'number'. Type 'undefined' is not assignable to type 'number'. -iteratorZip.ts(188,7): error TS2322: Type '({ a: IteratorZipValue; b: number; } & {})[]' is not assignable to type '{ a: number; b: number; }[]'. +a.ts(186,7): error TS2322: Type '({ a: IteratorZipValue; b: number; } & {})[]' is not assignable to type '{ a: number; b: number; }[]'. Type '{ a: IteratorZipValue; b: number; } & {}' is not assignable to type '{ a: number; b: number; }'. Types of property 'a' are incompatible. Type 'IteratorZipValue' is not assignable to type 'number'. Type 'undefined' is not assignable to type 'number'. -iteratorZip.ts(192,7): error TS2322: Type '({ [x: `a${string}`]: IteratorZipValue, `a${string}`, undefined, {}>; } & {})[]' is not assignable to type '{ [x: `a${string}`]: number; }[]'. +a.ts(190,7): error TS2322: Type '({ [x: `a${string}`]: IteratorZipValue, `a${string}`, undefined, {}>; } & {})[]' is not assignable to type '{ [x: `a${string}`]: number; }[]'. Type '{ [x: `a${string}`]: IteratorZipValue, `a${string}`, undefined, {}>; } & {}' is not assignable to type '{ [x: `a${string}`]: number; }'. '`a${string}`' index signatures are incompatible. Type 'IteratorZipValue, `a${string}`, undefined, {}>' is not assignable to type 'number'. Type 'undefined' is not assignable to type 'number'. -iteratorZip.ts(200,7): error TS2322: Type '({ a: number; b: IteratorZipValue & { a: number; }>; } & {})[]' is not assignable to type '{ a: number; b: number; }[]'. +a.ts(198,7): error TS2322: Type '({ a: number; b: IteratorZipValue & { a: number; }>; } & {})[]' is not assignable to type '{ a: number; b: number; }[]'. Type '{ a: number; b: IteratorZipValue & { a: number; }>; } & {}' is not assignable to type '{ a: number; b: number; }'. Types of property 'b' are incompatible. Type 'IteratorZipValue & { a: number; }>' is not assignable to type 'number'. Type 'undefined' is not assignable to type 'number'. -iteratorZip.ts(205,7): error TS2322: Type '[number, IteratorZipValue][]' is not assignable to type '[number, string][]'. +a.ts(203,7): error TS2322: Type '[number, IteratorZipValue][]' is not assignable to type '[number, string][]'. Type '[number, IteratorZipValue]' is not assignable to type '[number, string]'. Type at position 1 in source is not compatible with type at position 1 in target. Type 'IteratorZipValue' is not assignable to type 'string'. Type 'undefined' is not assignable to type 'string'. -iteratorZip.ts(238,7): error TS2322: Type 'unknown' is not assignable to type 'string'. -iteratorZip.ts(239,7): error TS2322: Type 'unknown' is not assignable to type 'string'. -iteratorZip.ts(255,7): error TS2322: Type 'Record[]' is not assignable to type 'never[]'. +a.ts(236,7): error TS2322: Type 'unknown' is not assignable to type 'string'. +a.ts(237,7): error TS2322: Type 'unknown' is not assignable to type 'string'. +a.ts(253,7): error TS2322: Type 'Record[]' is not assignable to type 'never[]'. Type 'Record' is not assignable to type 'never'. -iteratorZip.ts(260,7): error TS2322: Type 'Record[]' is not assignable to type 'never[]'. +a.ts(258,7): error TS2322: Type 'Record[]' is not assignable to type 'never[]'. Type 'Record' is not assignable to type 'never'. -iteratorZip.ts(262,19): error TS2769: No overload matches this call. +a.ts(260,19): error TS2769: No overload matches this call. The last overload gave the following error. Argument of type '0' is not assignable to parameter of type 'never'. -iteratorZip.ts(263,19): error TS2769: No overload matches this call. +a.ts(261,19): error TS2769: No overload matches this call. The last overload gave the following error. Argument of type 'null' is not assignable to parameter of type 'never'. -iteratorZip.ts(264,27): error TS2769: No overload matches this call. +a.ts(262,27): error TS2769: No overload matches this call. The last overload gave the following error. Type '"invalid"' is not assignable to type '"longest" | "shortest" | "strict" | undefined'. -iteratorZip.ts(265,45): error TS2769: No overload matches this call. +a.ts(263,45): error TS2769: No overload matches this call. The last overload gave the following error. Object literal may only specify known properties, and 'padding' does not exist in type 'IteratorZipShortestOptions'. -iteratorZip.ts(266,44): error TS2769: No overload matches this call. +a.ts(264,44): error TS2769: No overload matches this call. The last overload gave the following error. Type 'number' is not assignable to type 'object'. -iteratorZip.ts(267,19): error TS2769: No overload matches this call. +a.ts(272,7): error TS2322: Type '(number | boolean | undefined)[][]' is not assignable to type '(number | undefined)[][]'. + Type '(number | boolean | undefined)[]' is not assignable to type '(number | undefined)[]'. + Type 'number | boolean | undefined' is not assignable to type 'number | undefined'. + Type 'boolean' is not assignable to type 'number'. +a.ts(278,7): error TS2322: Type '({ a: IteratorZipValue; b: IteratorZipValue; } & {})[]' is not assignable to type '{ a: number | undefined; b: number | undefined; }[]'. + Type '{ a: IteratorZipValue; b: IteratorZipValue; } & {}' is not assignable to type '{ a: number | undefined; b: number | undefined; }'. + Types of property 'a' are incompatible. + Type 'IteratorZipValue' is not assignable to type 'number | undefined'. + Type 'boolean' is not assignable to type 'number'. +a.ts(285,7): error TS2322: Type '({ a: IteratorZipValue>; } & {})[]' is not assignable to type '{ a: number | boolean; }[]'. + Type '{ a: IteratorZipValue>; } & {}' is not assignable to type '{ a: number | boolean; }'. + Types of property 'a' are incompatible. + Type 'IteratorZipValue>' is not assignable to type 'number | boolean'. + Type 'undefined' is not assignable to type 'number | boolean'. +a.ts(299,7): error TS2322: Type '({ 0: IteratorZipValue; } & {})[]' is not assignable to type '{ 0: number; }[]'. + Type '{ 0: IteratorZipValue; } & {}' is not assignable to type '{ 0: number; }'. + Types of property '0' are incompatible. + Type 'IteratorZipValue' is not assignable to type 'number'. + Type 'undefined' is not assignable to type 'number'. +a.ts(304,7): error TS2322: Type '({ NaN: IteratorZipValue>; Infinity: IteratorZipValue>; "-Infinity": IteratorZipValue>; } & {})[]' is not assignable to type '{ NaN: number | undefined; Infinity: number | undefined; "-Infinity": number | undefined; }[]'. + Type '{ NaN: IteratorZipValue>; Infinity: IteratorZipValue>; "-Infinity": IteratorZipValue>; } & {}' is not assignable to type '{ NaN: number | undefined; Infinity: number | undefined; "-Infinity": number | undefined; }'. + Types of property 'NaN' are incompatible. + Type 'IteratorZipValue>' is not assignable to type 'number | undefined'. + Type 'boolean' is not assignable to type 'number'. +a.ts(307,7): error TS2322: Type '({ [x: string]: IteratorZipValue, string, undefined, { a: boolean; }>; } & {})[]' is not assignable to type 'Record[]'. + Type '{ [x: string]: IteratorZipValue, string, undefined, { a: boolean; }>; } & {}' is not assignable to type 'Record'. + 'string' index signatures are incompatible. + Type 'IteratorZipValue, string, undefined, { a: boolean; }>' is not assignable to type 'number | undefined'. + Type 'boolean' is not assignable to type 'number'. +a.ts(314,45): error TS2769: No overload matches this call. The last overload gave the following error. Argument of type '{ a: number[]; }' is not assignable to parameter of type 'never'. +a.ts(315,23): error TS2769: No overload matches this call. + The last overload gave the following error. + Argument of type '{}' is not assignable to parameter of type 'never'. +a.ts(316,80): error TS2769: No overload matches this call. + The last overload gave the following error. + Type 'number' is not assignable to type 'object'. -==== iteratorZip.ts (38 errors) ==== +==== a.ts (45 errors) ==== declare const a1: unique symbol; const a2: [number, string][] = Iterator.zip([ @@ -225,20 +251,7 @@ iteratorZip.ts(267,19): error TS2769: No overload matches this call. ~~~~ !!! error TS2769: No overload matches this call. !!! error TS2769: The last overload gave the following error. -!!! error TS2769: Type '"invalid"' is not assignable to type '"longest" | "shortest" | "strict"'. -!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. - - Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }); - ~~~~~~~ -!!! error TS2769: No overload matches this call. -!!! error TS2769: The last overload gave the following error. -!!! error TS2769: Type 'true[]' is not assignable to type 'Iterable<"a" | 1 | undefined> & object'. -!!! error TS2769: Type 'true[]' is not assignable to type 'Iterable<"a" | 1 | undefined>'. -!!! error TS2769: The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types. -!!! error TS2769: Type 'IteratorResult' is not assignable to type 'IteratorResult<"a" | 1 | undefined, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. -!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorResult<"a" | 1 | undefined, any>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. -!!! error TS2769: Type 'IteratorYieldResult' is not assignable to type 'IteratorYieldResult<"a" | 1 | undefined>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties. -!!! error TS2769: Type 'true' is not assignable to type '"a" | 1 | undefined'. +!!! error TS2769: Type '"invalid"' is not assignable to type '"longest" | "shortest" | "strict" | undefined'. !!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. Iterator.zip([[1]], { mode: "shortest", padding: [1] }); @@ -306,14 +319,14 @@ iteratorZip.ts(267,19): error TS2769: No overload matches this call. ~~~~~~~ !!! error TS2769: No overload matches this call. !!! error TS2769: The last overload gave the following error. -!!! error TS2769: Type 'string' is not assignable to type 'Iterable & object'. -!!! error TS2769: Type 'string' is not assignable to type 'Iterable'. +!!! error TS2769: Type 'string' is not assignable to type 'Iterable & object'. +!!! error TS2769: Type 'string' is not assignable to type 'object'. !!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); ~~~~~~~ !!! error TS2769: No overload matches this call. !!! error TS2769: The last overload gave the following error. -!!! error TS2769: Type 'string' is not assignable to type 'Iterable & object'. +!!! error TS2769: Type 'string' is not assignable to type 'Iterable & object'. !!! error TS2769: Type 'string' is not assignable to type 'object'. !!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); @@ -636,10 +649,147 @@ iteratorZip.ts(267,19): error TS2769: No overload matches this call. !!! error TS2769: The last overload gave the following error. !!! error TS2769: Type 'number' is not assignable to type 'object'. !!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. - Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: "invalid" } }); - ~~~~~~~~~~ + const a138: [number | boolean, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }).toArray(); + const a139: { a: number | string; b: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: { a: "a" } }).toArray(); + + declare const a140: boolean[]; + const a141: [number | boolean | undefined, string | boolean | undefined][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a140 }).toArray(); + const a142 = Iterator.zip(a12, { mode: "longest", padding: new Set([false]) }).toArray(); + const a143: (number | boolean | undefined)[][] = a142; + const a144: (number | undefined)[][] = a142; + ~~~~ +!!! error TS2322: Type '(number | boolean | undefined)[][]' is not assignable to type '(number | undefined)[][]'. +!!! error TS2322: Type '(number | boolean | undefined)[]' is not assignable to type '(number | undefined)[]'. +!!! error TS2322: Type 'number | boolean | undefined' is not assignable to type 'number | undefined'. +!!! error TS2322: Type 'boolean' is not assignable to type 'number'. + const a145: (number | boolean | undefined)[][] = Iterator.zip([[1], [2, 3]], { mode: "longest", padding: new Set([false]) }).toArray(); + + declare const a146: { a: boolean; } | { b: string; }; + const a147 = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a146 }).toArray(); + const a148: { a: number | boolean | undefined; b: number | string | undefined; }[] = a147; + const a149: { a: number | undefined; b: number | undefined; }[] = a147; + ~~~~ +!!! error TS2322: Type '({ a: IteratorZipValue; b: IteratorZipValue; } & {})[]' is not assignable to type '{ a: number | undefined; b: number | undefined; }[]'. +!!! error TS2322: Type '{ a: IteratorZipValue; b: IteratorZipValue; } & {}' is not assignable to type '{ a: number | undefined; b: number | undefined; }'. +!!! error TS2322: Types of property 'a' are incompatible. +!!! error TS2322: Type 'IteratorZipValue' is not assignable to type 'number | undefined'. +!!! error TS2322: Type 'boolean' is not assignable to type 'number'. + declare const a150: [boolean] | [string, string]; + const a151: [number | boolean | string, number | string | undefined][] = Iterator.zip([[1], [2, 3]], { mode: "longest", padding: a150 }).toArray(); + + declare const a152: { mode: "longest"; padding?: { a: boolean; }; }; + const a153 = Iterator.zipKeyed({ a: [1] }, a152).toArray(); + const a154: { a: number | boolean | undefined; }[] = a153; + const a155: { a: number | boolean; }[] = a153; + ~~~~ +!!! error TS2322: Type '({ a: IteratorZipValue>; } & {})[]' is not assignable to type '{ a: number | boolean; }[]'. +!!! error TS2322: Type '{ a: IteratorZipValue>; } & {}' is not assignable to type '{ a: number | boolean; }'. +!!! error TS2322: Types of property 'a' are incompatible. +!!! error TS2322: Type 'IteratorZipValue>' is not assignable to type 'number | boolean'. +!!! error TS2322: Type 'undefined' is not assignable to type 'number | boolean'. + declare const a156: { mode: "shortest"; } | { mode: "longest"; padding: [boolean]; } | undefined; + const a157: [number | boolean | undefined][] = Iterator.zip([[1]], a156).toArray(); + const a158: [number][] = Iterator.zip([[1]], { mode: undefined }).toArray(); + const a159: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: undefined }).toArray(); + + const a160: { a: number | { b: string; }; [a1]: boolean | string; }[] = Iterator.zipKeyed({ a: [1], [a1]: [true, false] }, { + mode: "longest", + padding: { a: { b: "a" }, [a1]: "a" }, + }).toArray(); + const a161: { "0": number | boolean; }[] = Iterator.zipKeyed({ "0": [1] }, { mode: "longest", padding: { 0: false } }).toArray(); + const a162: { 0: number | boolean; }[] = Iterator.zipKeyed({ 0: [1] }, { mode: "longest", padding: { "0": false } }).toArray(); + const a163 = Iterator.zipKeyed({ 0: [1] }, { mode: "longest", padding: { "01": false } }).toArray(); + const a164: { 0: number | undefined; }[] = a163; + const a165: { 0: number; }[] = a163; + ~~~~ +!!! error TS2322: Type '({ 0: IteratorZipValue; } & {})[]' is not assignable to type '{ 0: number; }[]'. +!!! error TS2322: Type '{ 0: IteratorZipValue; } & {}' is not assignable to type '{ 0: number; }'. +!!! error TS2322: Types of property '0' are incompatible. +!!! error TS2322: Type 'IteratorZipValue' is not assignable to type 'number'. +!!! error TS2322: Type 'undefined' is not assignable to type 'number'. + + declare const a166: Record; + const a167 = Iterator.zipKeyed({ NaN: [1], Infinity: [2], "-Infinity": [3] }, { mode: "longest", padding: a166 }).toArray(); + const a168: { NaN: number | boolean | undefined; Infinity: number | boolean | undefined; "-Infinity": number | boolean | undefined; }[] = a167; + const a169: { NaN: number | undefined; Infinity: number | undefined; "-Infinity": number | undefined; }[] = a167; + ~~~~ +!!! error TS2322: Type '({ NaN: IteratorZipValue>; Infinity: IteratorZipValue>; "-Infinity": IteratorZipValue>; } & {})[]' is not assignable to type '{ NaN: number | undefined; Infinity: number | undefined; "-Infinity": number | undefined; }[]'. +!!! error TS2322: Type '{ NaN: IteratorZipValue>; Infinity: IteratorZipValue>; "-Infinity": IteratorZipValue>; } & {}' is not assignable to type '{ NaN: number | undefined; Infinity: number | undefined; "-Infinity": number | undefined; }'. +!!! error TS2322: Types of property 'NaN' are incompatible. +!!! error TS2322: Type 'IteratorZipValue>' is not assignable to type 'number | undefined'. +!!! error TS2322: Type 'boolean' is not assignable to type 'number'. + const a170 = Iterator.zipKeyed(a58, { mode: "longest", padding: { a: false } }).toArray(); + const a171: Record[] = a170; + const a172: Record[] = a170; + ~~~~ +!!! error TS2322: Type '({ [x: string]: IteratorZipValue, string, undefined, { a: boolean; }>; } & {})[]' is not assignable to type 'Record[]'. +!!! error TS2322: Type '{ [x: string]: IteratorZipValue, string, undefined, { a: boolean; }>; } & {}' is not assignable to type 'Record'. +!!! error TS2322: 'string' index signatures are incompatible. +!!! error TS2322: Type 'IteratorZipValue, string, undefined, { a: boolean; }>' is not assignable to type 'number | undefined'. +!!! error TS2322: Type 'boolean' is not assignable to type 'number'. + + const a173: [number | undefined, string | undefined][] = Iterator.zip<[Iterable, Iterable]>([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); + const a174: (number | undefined)[][] = Iterator.zip>(a12, { mode: "longest", padding: [0] }).toArray(); + const a175: { a: number | undefined; }[] = Iterator.zipKeyed<{ a: Iterable; }>({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray(); + const a176: [number | boolean][] = Iterator.zip<[Iterable], [boolean]>([[1]], { mode: "longest", padding: [false] }).toArray(); + const a177: { a: number | boolean; }[] = Iterator.zipKeyed<{ a: Iterable; }, { a: boolean; }>({ a: [1] }, { mode: "longest", padding: { a: false } }).toArray(); + Iterator.zipKeyed<{ a: Iterable; }>({ a: [1] }, { mode: "longest", padding: 0 }); + ~~~~~~~~~~ !!! error TS2769: No overload matches this call. !!! error TS2769: The last overload gave the following error. !!! error TS2769: Argument of type '{ a: number[]; }' is not assignable to parameter of type 'never'. !!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + Iterator.zipKeyed<{}>({}, { mode: "longest", padding: 0 }); + ~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Argument of type '{}' is not assignable to parameter of type 'never'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + Iterator.zipKeyed<{ a: Iterable; }, {}>({ a: [1] }, { mode: "longest", padding: 0 }); + ~~~~~~~ +!!! error TS2769: No overload matches this call. +!!! error TS2769: The last overload gave the following error. +!!! error TS2769: Type 'number' is not assignable to type 'object'. +!!! related TS2771 lib.esnext.iterator.d.ts:--:--: The last overload is declared here. + +==== b.ts (0 errors) ==== + export function f1>>(a: T) { + return Iterator.zipKeyed(a); + } + + export function f2>>(a: T) { + return Iterator.zipKeyed(a, { mode: "longest" }); + } + + export function f3>>(a: T) { + return Iterator.zipKeyed(a, { mode: "longest", padding: {} }); + } + + export function f4(a: T) { + return Iterator.zipKeyed(a); + } + + export function f5(a: Iterable, b: U) { + return Iterator.zipKeyed({ a }, { mode: "longest", padding: { a: b } }); + } + + export function f6 | Iterator)[]>(a: T) { + return Iterator.zip(a); + } + + export function f7(a: Iterable, b: U) { + return Iterator.zipKeyed({ a }, { mode: "longest", padding: b }); + } + + export const a = f1({ a: [1], b: ["a"] }).toArray(); + export const b = f2({ a: [1], b: ["a"] }).toArray(); + export const c = f3({ a: [1], b: ["a"] }).toArray(); + export const d = f4({ a: [1], b: ["a"] }).toArray(); + export const e = f5([1], false).toArray(); + export const f = f6([[1], ["a"]] as const).toArray(); + export const g = f7([1], { a: false }).toArray(); + export const h = Iterator.zip; + export const i = Iterator.zipKeyed; + export const j = h([[1], ["a"]], { mode: "longest", padding: [false, false] }).toArray(); + export const k = i({ a: [1], b: [2, 3] }, { mode: "longest", padding: { a: false } }).toArray(); \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).js b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).js index e625116d58970..10ef94b9a2aaa 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).js +++ b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).js @@ -1,6 +1,6 @@ //// [tests/cases/compiler/iteratorZip.ts] //// -//// [iteratorZip.ts] +//// [a.ts] declare const a1: unique symbol; const a2: [number, string][] = Iterator.zip([ @@ -64,8 +64,6 @@ const a24: { a: number; b: string; }[] = Iterator.zipKeyed(a23).toArray(); Iterator.zip([[1]], { mode: "invalid" }); -Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }); - Iterator.zip([[1]], { mode: "shortest", padding: [1] }); Iterator.zip(0); @@ -267,10 +265,102 @@ Iterator.zipKeyed(null); Iterator.zipKeyed(a107, { mode: "invalid" }); Iterator.zipKeyed(a107, { mode: "shortest", padding: {} }); Iterator.zipKeyed(a107, { mode: "longest", padding: 0 }); -Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: "invalid" } }); +const a138: [number | boolean, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }).toArray(); +const a139: { a: number | string; b: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: { a: "a" } }).toArray(); + +declare const a140: boolean[]; +const a141: [number | boolean | undefined, string | boolean | undefined][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a140 }).toArray(); +const a142 = Iterator.zip(a12, { mode: "longest", padding: new Set([false]) }).toArray(); +const a143: (number | boolean | undefined)[][] = a142; +const a144: (number | undefined)[][] = a142; +const a145: (number | boolean | undefined)[][] = Iterator.zip([[1], [2, 3]], { mode: "longest", padding: new Set([false]) }).toArray(); + +declare const a146: { a: boolean; } | { b: string; }; +const a147 = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a146 }).toArray(); +const a148: { a: number | boolean | undefined; b: number | string | undefined; }[] = a147; +const a149: { a: number | undefined; b: number | undefined; }[] = a147; +declare const a150: [boolean] | [string, string]; +const a151: [number | boolean | string, number | string | undefined][] = Iterator.zip([[1], [2, 3]], { mode: "longest", padding: a150 }).toArray(); + +declare const a152: { mode: "longest"; padding?: { a: boolean; }; }; +const a153 = Iterator.zipKeyed({ a: [1] }, a152).toArray(); +const a154: { a: number | boolean | undefined; }[] = a153; +const a155: { a: number | boolean; }[] = a153; +declare const a156: { mode: "shortest"; } | { mode: "longest"; padding: [boolean]; } | undefined; +const a157: [number | boolean | undefined][] = Iterator.zip([[1]], a156).toArray(); +const a158: [number][] = Iterator.zip([[1]], { mode: undefined }).toArray(); +const a159: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: undefined }).toArray(); + +const a160: { a: number | { b: string; }; [a1]: boolean | string; }[] = Iterator.zipKeyed({ a: [1], [a1]: [true, false] }, { + mode: "longest", + padding: { a: { b: "a" }, [a1]: "a" }, +}).toArray(); +const a161: { "0": number | boolean; }[] = Iterator.zipKeyed({ "0": [1] }, { mode: "longest", padding: { 0: false } }).toArray(); +const a162: { 0: number | boolean; }[] = Iterator.zipKeyed({ 0: [1] }, { mode: "longest", padding: { "0": false } }).toArray(); +const a163 = Iterator.zipKeyed({ 0: [1] }, { mode: "longest", padding: { "01": false } }).toArray(); +const a164: { 0: number | undefined; }[] = a163; +const a165: { 0: number; }[] = a163; + +declare const a166: Record; +const a167 = Iterator.zipKeyed({ NaN: [1], Infinity: [2], "-Infinity": [3] }, { mode: "longest", padding: a166 }).toArray(); +const a168: { NaN: number | boolean | undefined; Infinity: number | boolean | undefined; "-Infinity": number | boolean | undefined; }[] = a167; +const a169: { NaN: number | undefined; Infinity: number | undefined; "-Infinity": number | undefined; }[] = a167; +const a170 = Iterator.zipKeyed(a58, { mode: "longest", padding: { a: false } }).toArray(); +const a171: Record[] = a170; +const a172: Record[] = a170; + +const a173: [number | undefined, string | undefined][] = Iterator.zip<[Iterable, Iterable]>([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); +const a174: (number | undefined)[][] = Iterator.zip>(a12, { mode: "longest", padding: [0] }).toArray(); +const a175: { a: number | undefined; }[] = Iterator.zipKeyed<{ a: Iterable; }>({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray(); +const a176: [number | boolean][] = Iterator.zip<[Iterable], [boolean]>([[1]], { mode: "longest", padding: [false] }).toArray(); +const a177: { a: number | boolean; }[] = Iterator.zipKeyed<{ a: Iterable; }, { a: boolean; }>({ a: [1] }, { mode: "longest", padding: { a: false } }).toArray(); +Iterator.zipKeyed<{ a: Iterable; }>({ a: [1] }, { mode: "longest", padding: 0 }); +Iterator.zipKeyed<{}>({}, { mode: "longest", padding: 0 }); +Iterator.zipKeyed<{ a: Iterable; }, {}>({ a: [1] }, { mode: "longest", padding: 0 }); + +//// [b.ts] +export function f1>>(a: T) { + return Iterator.zipKeyed(a); +} + +export function f2>>(a: T) { + return Iterator.zipKeyed(a, { mode: "longest" }); +} + +export function f3>>(a: T) { + return Iterator.zipKeyed(a, { mode: "longest", padding: {} }); +} + +export function f4(a: T) { + return Iterator.zipKeyed(a); +} + +export function f5(a: Iterable, b: U) { + return Iterator.zipKeyed({ a }, { mode: "longest", padding: { a: b } }); +} + +export function f6 | Iterator)[]>(a: T) { + return Iterator.zip(a); +} + +export function f7(a: Iterable, b: U) { + return Iterator.zipKeyed({ a }, { mode: "longest", padding: b }); +} + +export const a = f1({ a: [1], b: ["a"] }).toArray(); +export const b = f2({ a: [1], b: ["a"] }).toArray(); +export const c = f3({ a: [1], b: ["a"] }).toArray(); +export const d = f4({ a: [1], b: ["a"] }).toArray(); +export const e = f5([1], false).toArray(); +export const f = f6([[1], ["a"]] as const).toArray(); +export const g = f7([1], { a: false }).toArray(); +export const h = Iterator.zip; +export const i = Iterator.zipKeyed; +export const j = h([[1], ["a"]], { mode: "longest", padding: [false, false] }).toArray(); +export const k = i({ a: [1], b: [2, 3] }, { mode: "longest", padding: { a: false } }).toArray(); -//// [iteratorZip.js] +//// [a.js] "use strict"; const a2 = Iterator.zip([ [1, 2], @@ -309,7 +399,6 @@ const a21 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { const a22 = Iterator.zipKeyed({ a: [1], b: ["a"] }, a8).toArray(); const a24 = Iterator.zipKeyed(a23).toArray(); Iterator.zip([[1]], { mode: "invalid" }); -Iterator.zip([[1], ["a"]], { mode: "longest", padding: [true] }); Iterator.zip([[1]], { mode: "shortest", padding: [1] }); Iterator.zip(0); Iterator.zipKeyed({ a: 0 }); @@ -444,10 +533,82 @@ Iterator.zipKeyed(null); Iterator.zipKeyed(a107, { mode: "invalid" }); Iterator.zipKeyed(a107, { mode: "shortest", padding: {} }); Iterator.zipKeyed(a107, { mode: "longest", padding: 0 }); -Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: "invalid" } }); +const a138 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [true] }).toArray(); +const a139 = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: { a: "a" } }).toArray(); +const a141 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a140 }).toArray(); +const a142 = Iterator.zip(a12, { mode: "longest", padding: new Set([false]) }).toArray(); +const a143 = a142; +const a144 = a142; +const a145 = Iterator.zip([[1], [2, 3]], { mode: "longest", padding: new Set([false]) }).toArray(); +const a147 = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a146 }).toArray(); +const a148 = a147; +const a149 = a147; +const a151 = Iterator.zip([[1], [2, 3]], { mode: "longest", padding: a150 }).toArray(); +const a153 = Iterator.zipKeyed({ a: [1] }, a152).toArray(); +const a154 = a153; +const a155 = a153; +const a157 = Iterator.zip([[1]], a156).toArray(); +const a158 = Iterator.zip([[1]], { mode: undefined }).toArray(); +const a159 = Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: undefined }).toArray(); +const a160 = Iterator.zipKeyed({ a: [1], [a1]: [true, false] }, { + mode: "longest", + padding: { a: { b: "a" }, [a1]: "a" }, +}).toArray(); +const a161 = Iterator.zipKeyed({ "0": [1] }, { mode: "longest", padding: { 0: false } }).toArray(); +const a162 = Iterator.zipKeyed({ 0: [1] }, { mode: "longest", padding: { "0": false } }).toArray(); +const a163 = Iterator.zipKeyed({ 0: [1] }, { mode: "longest", padding: { "01": false } }).toArray(); +const a164 = a163; +const a165 = a163; +const a167 = Iterator.zipKeyed({ NaN: [1], Infinity: [2], "-Infinity": [3] }, { mode: "longest", padding: a166 }).toArray(); +const a168 = a167; +const a169 = a167; +const a170 = Iterator.zipKeyed(a58, { mode: "longest", padding: { a: false } }).toArray(); +const a171 = a170; +const a172 = a170; +const a173 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); +const a174 = Iterator.zip(a12, { mode: "longest", padding: [0] }).toArray(); +const a175 = Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray(); +const a176 = Iterator.zip([[1]], { mode: "longest", padding: [false] }).toArray(); +const a177 = Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: false } }).toArray(); +Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: 0 }); +Iterator.zipKeyed({}, { mode: "longest", padding: 0 }); +Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: 0 }); +//// [b.js] +export function f1(a) { + return Iterator.zipKeyed(a); +} +export function f2(a) { + return Iterator.zipKeyed(a, { mode: "longest" }); +} +export function f3(a) { + return Iterator.zipKeyed(a, { mode: "longest", padding: {} }); +} +export function f4(a) { + return Iterator.zipKeyed(a); +} +export function f5(a, b) { + return Iterator.zipKeyed({ a }, { mode: "longest", padding: { a: b } }); +} +export function f6(a) { + return Iterator.zip(a); +} +export function f7(a, b) { + return Iterator.zipKeyed({ a }, { mode: "longest", padding: b }); +} +export const a = f1({ a: [1], b: ["a"] }).toArray(); +export const b = f2({ a: [1], b: ["a"] }).toArray(); +export const c = f3({ a: [1], b: ["a"] }).toArray(); +export const d = f4({ a: [1], b: ["a"] }).toArray(); +export const e = f5([1], false).toArray(); +export const f = f6([[1], ["a"]]).toArray(); +export const g = f7([1], { a: false }).toArray(); +export const h = Iterator.zip; +export const i = Iterator.zipKeyed; +export const j = h([[1], ["a"]], { mode: "longest", padding: [false, false] }).toArray(); +export const k = i({ a: [1], b: [2, 3] }, { mode: "longest", padding: { a: false } }).toArray(); -//// [iteratorZip.d.ts] +//// [a.d.ts] declare const a1: unique symbol; declare const a2: [number, string][]; declare const a3: [number, string][]; @@ -782,3 +943,221 @@ declare const a134: {}; declare const a135: Record[]; declare const a136: unknown; declare const a137: never[]; +declare const a138: [number | boolean, string | undefined][]; +declare const a139: { + a: number | string; + b: number | undefined; +}[]; +declare const a140: boolean[]; +declare const a141: [number | boolean | undefined, string | boolean | undefined][]; +declare const a142: (number | boolean | undefined)[][]; +declare const a143: (number | boolean | undefined)[][]; +declare const a144: (number | undefined)[][]; +declare const a145: (number | boolean | undefined)[][]; +declare const a146: { + a: boolean; +} | { + b: string; +}; +declare const a147: ({ + a: number | boolean | undefined; + b: string | number | undefined; +} & {})[]; +declare const a148: { + a: number | boolean | undefined; + b: number | string | undefined; +}[]; +declare const a149: { + a: number | undefined; + b: number | undefined; +}[]; +declare const a150: [boolean] | [string, string]; +declare const a151: [number | boolean | string, number | string | undefined][]; +declare const a152: { + mode: "longest"; + padding?: { + a: boolean; + }; +}; +declare const a153: ({ + a: number | boolean | undefined; +} & {})[]; +declare const a154: { + a: number | boolean | undefined; +}[]; +declare const a155: { + a: number | boolean; +}[]; +declare const a156: { + mode: "shortest"; +} | { + mode: "longest"; + padding: [boolean]; +} | undefined; +declare const a157: [number | boolean | undefined][]; +declare const a158: [number][]; +declare const a159: { + a: number | undefined; +}[]; +declare const a160: { + a: number | { + b: string; + }; + [a1]: boolean | string; +}[]; +declare const a161: { + "0": number | boolean; +}[]; +declare const a162: { + 0: number | boolean; +}[]; +declare const a163: ({ + 0: number | undefined; +} & {})[]; +declare const a164: { + 0: number | undefined; +}[]; +declare const a165: { + 0: number; +}[]; +declare const a166: Record; +declare const a167: ({ + NaN: number | boolean | undefined; + Infinity: number | boolean | undefined; + "-Infinity": number | boolean | undefined; +} & {})[]; +declare const a168: { + NaN: number | boolean | undefined; + Infinity: number | boolean | undefined; + "-Infinity": number | boolean | undefined; +}[]; +declare const a169: { + NaN: number | undefined; + Infinity: number | undefined; + "-Infinity": number | undefined; +}[]; +declare const a170: ({ + [x: string]: number | boolean | undefined; +} & {})[]; +declare const a171: Record[]; +declare const a172: Record[]; +declare const a173: [number | undefined, string | undefined][]; +declare const a174: (number | undefined)[][]; +declare const a175: { + a: number | undefined; +}[]; +declare const a176: [number | boolean][]; +declare const a177: { + a: number | boolean; +}[]; +//// [b.d.ts] +export declare function f1>>(a: T): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; +export declare function f2>>(a: T): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> extends infer T_2 ? T_2 extends Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> as {} extends Pick | Iterator) & object ? U : never : never : never) | undefined; }>, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> extends infer T_2 ? T_2 extends Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> as {} extends Pick | Iterator) & object ? U : never : never : never) | undefined; }>, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; +export declare function f3>>(a: T): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : undefined); }, undefined, unknown>; +export declare function f4(a: T): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; +export declare function f5(a: Iterable, b: U): IteratorObject<{ + a: T | U; +} & {}, undefined, unknown>; +export declare function f6 | Iterator)[]>(a: T): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; +export declare function f7(a: Iterable, b: U): IteratorObject<{ + a: T | (U extends unknown ? U["a" & keyof U] : never) | ("a" extends keyof { [K in keyof U as {} extends Pick ? never : K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K]: unknown; } ? never : undefined); +} & {}, undefined, unknown>; +export declare const a: ({ + a: number; + b: string; +} & {})[]; +export declare const b: ({ + a: number | undefined; + b: string | undefined; +} & {})[]; +export declare const c: ({ + a: number | undefined; + b: string | undefined; +} & {})[]; +export declare const d: ({ + a: number; + b: string; +} & {})[]; +export declare const e: ({ + a: number | boolean; +} & {})[]; +export declare const f: [1, "a"][]; +export declare const g: ({ + a: number | boolean; +} & {})[]; +export declare const h: { + (iterables: readonly [], options?: { + mode: "longest"; + padding?: (Iterable & object) | undefined; + } | { + mode?: "shortest" | undefined; + } | { + mode: "strict"; + }): IteratorObject; + | Iterator) & object)[] | []>(iterables: T, options?: { + mode?: "shortest" | undefined; + } | { + mode: "strict"; + }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; + | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { + mode: "longest"; + padding?: (TPadding & object) | undefined; + } & { + padding: TPadding; + }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; + | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ + mode: "longest"; + padding?: (TPadding & object) | undefined; + } | { + mode?: "shortest" | undefined; + } | { + mode: "strict"; + }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; + | Iterator) & object>(iterables: Iterable & object, options?: { + mode?: "shortest" | undefined; + } | { + mode: "strict"; + }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; + | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ + mode: "longest"; + padding?: (Iterable & object) | undefined; + } | { + mode?: "shortest" | undefined; + } | { + mode: "strict"; + }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; +}; +export declare const i: { + (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { + mode?: "shortest" | undefined; + } | { + mode: "strict"; + }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; + (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { + mode: "longest"; + padding?: (TPadding & object) | undefined; + } & { + padding: TPadding; + }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; + | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ + mode: "longest"; + padding?: (TPadding & object) | undefined; + } | { + mode?: "shortest" | undefined; + } | { + mode: "strict"; + }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; + (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { + mode: "longest"; + padding?: object | undefined; + } | { + mode?: "shortest" | undefined; + } | { + mode: "strict"; + }): IteratorObject, undefined, unknown>; +}; +export declare const j: [number | boolean, string | boolean][]; +export declare const k: ({ + a: number | boolean; + b: number | undefined; +} & {})[]; diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).symbols b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).symbols index 14821dd34b801..6ce9848b374fa 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).symbols +++ b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).symbols @@ -1,11 +1,11 @@ //// [tests/cases/compiler/iteratorZip.ts] //// -=== iteratorZip.ts === +=== a.ts === declare const a1: unique symbol; ->a1 : Symbol(a1, Decl(iteratorZip.ts, 0, 13)) +>a1 : Symbol(a1, Decl(a.ts, 0, 13)) const a2: [number, string][] = Iterator.zip([ ->a2 : Symbol(a2, Decl(iteratorZip.ts, 2, 5)) +>a2 : Symbol(a2, Decl(a.ts, 2, 5)) >Iterator.zip([ [1, 2], new Set(["a", "b"]),] as const).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) @@ -20,78 +20,78 @@ const a2: [number, string][] = Iterator.zip([ >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) a2[0][0] = 2; ->a2 : Symbol(a2, Decl(iteratorZip.ts, 2, 5)) +>a2 : Symbol(a2, Decl(a.ts, 2, 5)) >0 : Symbol(0) const a3: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray(); ->a3 : Symbol(a3, Decl(iteratorZip.ts, 9, 5)) +>a3 : Symbol(a3, Decl(a.ts, 9, 5)) >Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >const : Symbol(const) ->mode : Symbol(mode, Decl(iteratorZip.ts, 9, 68)) +>mode : Symbol(mode, Decl(a.ts, 9, 68)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a4: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray(); ->a4 : Symbol(a4, Decl(iteratorZip.ts, 10, 5)) +>a4 : Symbol(a4, Decl(a.ts, 10, 5)) >Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >const : Symbol(const) ->mode : Symbol(mode, Decl(iteratorZip.ts, 10, 68)) +>mode : Symbol(mode, Decl(a.ts, 10, 68)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a5: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray(); ->a5 : Symbol(a5, Decl(iteratorZip.ts, 11, 5)) +>a5 : Symbol(a5, Decl(a.ts, 11, 5)) >Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >const : Symbol(const) ->mode : Symbol(mode, Decl(iteratorZip.ts, 11, 68)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 11, 85)) +>mode : Symbol(mode, Decl(a.ts, 11, 68)) +>padding : Symbol(padding, Decl(a.ts, 11, 85)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a6: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray(); ->a6 : Symbol(a6, Decl(iteratorZip.ts, 12, 5)) +>a6 : Symbol(a6, Decl(a.ts, 12, 5)) >Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >const : Symbol(const) ->mode : Symbol(mode, Decl(iteratorZip.ts, 12, 92)) +>mode : Symbol(mode, Decl(a.ts, 12, 92)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a7: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray(); ->a7 : Symbol(a7, Decl(iteratorZip.ts, 13, 5)) +>a7 : Symbol(a7, Decl(a.ts, 13, 5)) >Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >const : Symbol(const) ->mode : Symbol(mode, Decl(iteratorZip.ts, 13, 92)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 13, 109)) +>mode : Symbol(mode, Decl(a.ts, 13, 92)) +>padding : Symbol(padding, Decl(a.ts, 13, 109)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) declare const a8: { mode: "shortest"; } | { mode: "longest"; }; ->a8 : Symbol(a8, Decl(iteratorZip.ts, 15, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 15, 19)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 15, 43)) +>a8 : Symbol(a8, Decl(a.ts, 15, 13)) +>mode : Symbol(mode, Decl(a.ts, 15, 19)) +>mode : Symbol(mode, Decl(a.ts, 15, 43)) const a9: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] as const, a8).toArray(); ->a9 : Symbol(a9, Decl(iteratorZip.ts, 16, 5)) +>a9 : Symbol(a9, Decl(a.ts, 16, 5)) >Iterator.zip([[1], ["a"]] as const, a8).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >const : Symbol(const) ->a8 : Symbol(a8, Decl(iteratorZip.ts, 15, 13)) +>a8 : Symbol(a8, Decl(a.ts, 15, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a10: never[] = Iterator.zip([]).toArray(); ->a10 : Symbol(a10, Decl(iteratorZip.ts, 18, 5)) +>a10 : Symbol(a10, Decl(a.ts, 18, 5)) >Iterator.zip([]).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) @@ -99,218 +99,210 @@ const a10: never[] = Iterator.zip([]).toArray(); >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a11: never[] = Iterator.zip([], { mode: "longest" }).toArray(); ->a11 : Symbol(a11, Decl(iteratorZip.ts, 19, 5)) +>a11 : Symbol(a11, Decl(a.ts, 19, 5)) >Iterator.zip([], { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 19, 39)) +>mode : Symbol(mode, Decl(a.ts, 19, 39)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) declare const a12: Iterable>; ->a12 : Symbol(a12, Decl(iteratorZip.ts, 21, 13)) +>a12 : Symbol(a12, Decl(a.ts, 21, 13)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) const a13: number[][] = Iterator.zip(a12).toArray(); ->a13 : Symbol(a13, Decl(iteratorZip.ts, 22, 5)) +>a13 : Symbol(a13, Decl(a.ts, 22, 5)) >Iterator.zip(a12).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->a12 : Symbol(a12, Decl(iteratorZip.ts, 21, 13)) +>a12 : Symbol(a12, Decl(a.ts, 21, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a14: (number | undefined)[][] = Iterator.zip(a12, { mode: "longest" }).toArray(); ->a14 : Symbol(a14, Decl(iteratorZip.ts, 23, 5)) +>a14 : Symbol(a14, Decl(a.ts, 23, 5)) >Iterator.zip(a12, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->a12 : Symbol(a12, Decl(iteratorZip.ts, 21, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 23, 57)) +>a12 : Symbol(a12, Decl(a.ts, 21, 13)) +>mode : Symbol(mode, Decl(a.ts, 23, 57)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a15: (number | undefined)[][] = Iterator.zip(a12, a8).toArray(); ->a15 : Symbol(a15, Decl(iteratorZip.ts, 24, 5)) +>a15 : Symbol(a15, Decl(a.ts, 24, 5)) >Iterator.zip(a12, a8).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->a12 : Symbol(a12, Decl(iteratorZip.ts, 21, 13)) ->a8 : Symbol(a8, Decl(iteratorZip.ts, 15, 13)) +>a12 : Symbol(a12, Decl(a.ts, 21, 13)) +>a8 : Symbol(a8, Decl(a.ts, 15, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) declare const a16: Iterable[]; ->a16 : Symbol(a16, Decl(iteratorZip.ts, 26, 13)) +>a16 : Symbol(a16, Decl(a.ts, 26, 13)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) const a17: (number | undefined)[][] = Iterator.zip(a16, { mode: "longest", padding: [] }).toArray(); ->a17 : Symbol(a17, Decl(iteratorZip.ts, 27, 5)) +>a17 : Symbol(a17, Decl(a.ts, 27, 5)) >Iterator.zip(a16, { mode: "longest", padding: [] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->a16 : Symbol(a16, Decl(iteratorZip.ts, 26, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 27, 57)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 27, 74)) +>a16 : Symbol(a16, Decl(a.ts, 26, 13)) +>mode : Symbol(mode, Decl(a.ts, 27, 57)) +>padding : Symbol(padding, Decl(a.ts, 27, 74)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a18: { a: number; b: string; [a1]: boolean; }[] = Iterator.zipKeyed({ ->a18 : Symbol(a18, Decl(iteratorZip.ts, 29, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 29, 12)) ->b : Symbol(b, Decl(iteratorZip.ts, 29, 23)) ->[a1] : Symbol([a1], Decl(iteratorZip.ts, 29, 34)) ->a1 : Symbol(a1, Decl(iteratorZip.ts, 0, 13)) +>a18 : Symbol(a18, Decl(a.ts, 29, 5)) +>a : Symbol(a, Decl(a.ts, 29, 12)) +>b : Symbol(b, Decl(a.ts, 29, 23)) +>[a1] : Symbol([a1], Decl(a.ts, 29, 34)) +>a1 : Symbol(a1, Decl(a.ts, 0, 13)) >Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [a1]: [true, false],} as const).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) a: [1, 2], ->a : Symbol(a, Decl(iteratorZip.ts, 29, 75)) +>a : Symbol(a, Decl(a.ts, 29, 75)) b: new Set(["a", "b"]), ->b : Symbol(b, Decl(iteratorZip.ts, 30, 14)) +>b : Symbol(b, Decl(a.ts, 30, 14)) >Set : Symbol(Set, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) [a1]: [true, false], ->[a1] : Symbol([a1], Decl(iteratorZip.ts, 31, 27)) ->a1 : Symbol(a1, Decl(iteratorZip.ts, 0, 13)) +>[a1] : Symbol([a1], Decl(a.ts, 31, 27)) +>a1 : Symbol(a1, Decl(a.ts, 0, 13)) } as const).toArray(); >const : Symbol(const) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) a18[0].a = 2; ->a18[0].a : Symbol(a, Decl(iteratorZip.ts, 29, 12)) ->a18 : Symbol(a18, Decl(iteratorZip.ts, 29, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 29, 12)) +>a18[0].a : Symbol(a, Decl(a.ts, 29, 12)) +>a18 : Symbol(a18, Decl(a.ts, 29, 5)) +>a : Symbol(a, Decl(a.ts, 29, 12)) const a19: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { ->a19 : Symbol(a19, Decl(iteratorZip.ts, 37, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 37, 12)) ->b : Symbol(b, Decl(iteratorZip.ts, 37, 23)) +>a19 : Symbol(a19, Decl(a.ts, 37, 5)) +>a : Symbol(a, Decl(a.ts, 37, 12)) +>b : Symbol(b, Decl(a.ts, 37, 23)) >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 37, 60)) ->b : Symbol(b, Decl(iteratorZip.ts, 37, 68)) +>a : Symbol(a, Decl(a.ts, 37, 60)) +>b : Symbol(b, Decl(a.ts, 37, 68)) >const : Symbol(const) mode: "longest", ->mode : Symbol(mode, Decl(iteratorZip.ts, 37, 91)) +>mode : Symbol(mode, Decl(a.ts, 37, 91)) padding: { a: 1, b: "a" }, ->padding : Symbol(padding, Decl(iteratorZip.ts, 38, 20)) ->a : Symbol(a, Decl(iteratorZip.ts, 39, 14)) ->b : Symbol(b, Decl(iteratorZip.ts, 39, 20)) +>padding : Symbol(padding, Decl(a.ts, 38, 20)) +>a : Symbol(a, Decl(a.ts, 39, 14)) +>b : Symbol(b, Decl(a.ts, 39, 20)) }).toArray(); >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a20: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { ->a20 : Symbol(a20, Decl(iteratorZip.ts, 42, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 42, 12)) ->b : Symbol(b, Decl(iteratorZip.ts, 42, 35)) +>a20 : Symbol(a20, Decl(a.ts, 42, 5)) +>a : Symbol(a, Decl(a.ts, 42, 12)) +>b : Symbol(b, Decl(a.ts, 42, 35)) >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 42, 84)) ->b : Symbol(b, Decl(iteratorZip.ts, 42, 92)) +>a : Symbol(a, Decl(a.ts, 42, 84)) +>b : Symbol(b, Decl(a.ts, 42, 92)) >const : Symbol(const) mode: "longest", ->mode : Symbol(mode, Decl(iteratorZip.ts, 42, 115)) +>mode : Symbol(mode, Decl(a.ts, 42, 115)) }).toArray(); >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a21: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { ->a21 : Symbol(a21, Decl(iteratorZip.ts, 46, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 46, 12)) ->b : Symbol(b, Decl(iteratorZip.ts, 46, 35)) +>a21 : Symbol(a21, Decl(a.ts, 46, 5)) +>a : Symbol(a, Decl(a.ts, 46, 12)) +>b : Symbol(b, Decl(a.ts, 46, 35)) >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 46, 84)) ->b : Symbol(b, Decl(iteratorZip.ts, 46, 92)) +>a : Symbol(a, Decl(a.ts, 46, 84)) +>b : Symbol(b, Decl(a.ts, 46, 92)) >const : Symbol(const) mode: "longest", ->mode : Symbol(mode, Decl(iteratorZip.ts, 46, 115)) +>mode : Symbol(mode, Decl(a.ts, 46, 115)) padding: { b: "a" }, ->padding : Symbol(padding, Decl(iteratorZip.ts, 47, 20)) ->b : Symbol(b, Decl(iteratorZip.ts, 48, 14)) +>padding : Symbol(padding, Decl(a.ts, 47, 20)) +>b : Symbol(b, Decl(a.ts, 48, 14)) }).toArray(); >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a22: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } as const, a8).toArray(); ->a22 : Symbol(a22, Decl(iteratorZip.ts, 51, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 51, 12)) ->b : Symbol(b, Decl(iteratorZip.ts, 51, 35)) +>a22 : Symbol(a22, Decl(a.ts, 51, 5)) +>a : Symbol(a, Decl(a.ts, 51, 12)) +>b : Symbol(b, Decl(a.ts, 51, 35)) >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, a8).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 51, 84)) ->b : Symbol(b, Decl(iteratorZip.ts, 51, 92)) +>a : Symbol(a, Decl(a.ts, 51, 84)) +>b : Symbol(b, Decl(a.ts, 51, 92)) >const : Symbol(const) ->a8 : Symbol(a8, Decl(iteratorZip.ts, 15, 13)) +>a8 : Symbol(a8, Decl(a.ts, 15, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) interface I1 { ->I1 : Symbol(I1, Decl(iteratorZip.ts, 51, 128)) +>I1 : Symbol(I1, Decl(a.ts, 51, 128)) a: Iterable; ->a : Symbol(I1.a, Decl(iteratorZip.ts, 53, 14)) +>a : Symbol(I1.a, Decl(a.ts, 53, 14)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) b: Iterator; ->b : Symbol(I1.b, Decl(iteratorZip.ts, 54, 24)) +>b : Symbol(I1.b, Decl(a.ts, 54, 24)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) } declare const a23: I1; ->a23 : Symbol(a23, Decl(iteratorZip.ts, 58, 13)) ->I1 : Symbol(I1, Decl(iteratorZip.ts, 51, 128)) +>a23 : Symbol(a23, Decl(a.ts, 58, 13)) +>I1 : Symbol(I1, Decl(a.ts, 51, 128)) const a24: { a: number; b: string; }[] = Iterator.zipKeyed(a23).toArray(); ->a24 : Symbol(a24, Decl(iteratorZip.ts, 59, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 59, 12)) ->b : Symbol(b, Decl(iteratorZip.ts, 59, 23)) +>a24 : Symbol(a24, Decl(a.ts, 59, 5)) +>a : Symbol(a, Decl(a.ts, 59, 12)) +>b : Symbol(b, Decl(a.ts, 59, 23)) >Iterator.zipKeyed(a23).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a23 : Symbol(a23, Decl(iteratorZip.ts, 58, 13)) +>a23 : Symbol(a23, Decl(a.ts, 58, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) Iterator.zip([[1]], { mode: "invalid" }); >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 61, 21)) - -Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }); ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->const : Symbol(const) ->mode : Symbol(mode, Decl(iteratorZip.ts, 63, 37)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 63, 54)) +>mode : Symbol(mode, Decl(a.ts, 61, 21)) Iterator.zip([[1]], { mode: "shortest", padding: [1] }); >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 65, 21)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 65, 39)) +>mode : Symbol(mode, Decl(a.ts, 63, 21)) +>padding : Symbol(padding, Decl(a.ts, 63, 39)) Iterator.zip(0); >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) @@ -321,10 +313,10 @@ Iterator.zipKeyed({ a: 0 }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 69, 19)) +>a : Symbol(a, Decl(a.ts, 67, 19)) const a25: Record[] = Iterator.zipKeyed({}).toArray(); ->a25 : Symbol(a25, Decl(iteratorZip.ts, 71, 5)) +>a25 : Symbol(a25, Decl(a.ts, 69, 5)) >Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) >PropertyKey : Symbol(PropertyKey, Decl(lib.es5.d.ts, --, --)) >Iterator.zipKeyed({}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) @@ -334,33 +326,33 @@ const a25: Record[] = Iterator.zipKeyed({}).toArray(); >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a26: Record[] = Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray(); ->a26 : Symbol(a26, Decl(iteratorZip.ts, 72, 5)) +>a26 : Symbol(a26, Decl(a.ts, 70, 5)) >Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) >PropertyKey : Symbol(PropertyKey, Decl(lib.es5.d.ts, --, --)) >Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 72, 67)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 72, 84)) +>mode : Symbol(mode, Decl(a.ts, 70, 67)) +>padding : Symbol(padding, Decl(a.ts, 70, 84)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) declare const a27: { a: Iterable; } | { b: Iterator; }; ->a27 : Symbol(a27, Decl(iteratorZip.ts, 74, 13)) ->a : Symbol(a, Decl(iteratorZip.ts, 74, 20)) +>a27 : Symbol(a27, Decl(a.ts, 72, 13)) +>a : Symbol(a, Decl(a.ts, 72, 20)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->b : Symbol(b, Decl(iteratorZip.ts, 74, 47)) +>b : Symbol(b, Decl(a.ts, 72, 47)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) const a28: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(a27).toArray(); ->a28 : Symbol(a28, Decl(iteratorZip.ts, 75, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 75, 13)) ->b : Symbol(b, Decl(iteratorZip.ts, 75, 30)) +>a28 : Symbol(a28, Decl(a.ts, 73, 5)) +>a : Symbol(a, Decl(a.ts, 73, 13)) +>b : Symbol(b, Decl(a.ts, 73, 30)) >Iterator.zipKeyed(a27).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a27 : Symbol(a27, Decl(iteratorZip.ts, 74, 13)) +>a27 : Symbol(a27, Decl(a.ts, 72, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) Iterator.zip("ab"); @@ -388,31 +380,31 @@ Iterator.zipKeyed({ a: "ab" }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 81, 19)) +>a : Symbol(a, Decl(a.ts, 79, 19)) Iterator.zip([], { mode: "longest", padding: "ab" }); >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 82, 18)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 82, 35)) +>mode : Symbol(mode, Decl(a.ts, 80, 18)) +>padding : Symbol(padding, Decl(a.ts, 80, 35)) Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 83, 23)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 83, 40)) +>mode : Symbol(mode, Decl(a.ts, 81, 23)) +>padding : Symbol(padding, Decl(a.ts, 81, 40)) Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 84, 23)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 84, 40)) +>mode : Symbol(mode, Decl(a.ts, 82, 23)) +>padding : Symbol(padding, Decl(a.ts, 82, 40)) const a29: [string][] = Iterator.zip([new String("ab")]).toArray(); ->a29 : Symbol(a29, Decl(iteratorZip.ts, 86, 5)) +>a29 : Symbol(a29, Decl(a.ts, 84, 5)) >Iterator.zip([new String("ab")]).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) @@ -421,252 +413,252 @@ const a29: [string][] = Iterator.zip([new String("ab")]).toArray(); >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a30: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray(); ->a30 : Symbol(a30, Decl(iteratorZip.ts, 87, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 87, 12)) +>a30 : Symbol(a30, Decl(a.ts, 85, 5)) +>a : Symbol(a, Decl(a.ts, 85, 12)) >Iterator.zipKeyed({ a: new String("ab") }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 87, 49)) +>a : Symbol(a, Decl(a.ts, 85, 49)) >String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a31: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray(); ->a31 : Symbol(a31, Decl(iteratorZip.ts, 88, 5)) +>a31 : Symbol(a31, Decl(a.ts, 86, 5)) >Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 88, 61)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 88, 78)) +>mode : Symbol(mode, Decl(a.ts, 86, 61)) +>padding : Symbol(padding, Decl(a.ts, 86, 78)) >String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a32 = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); ->a32 : Symbol(a32, Decl(iteratorZip.ts, 90, 5)) +>a32 : Symbol(a32, Decl(a.ts, 88, 5)) >Iterator.zipKeyed({ a: [1], b: undefined }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 90, 31)) ->b : Symbol(b, Decl(iteratorZip.ts, 90, 39)) +>a : Symbol(a, Decl(a.ts, 88, 31)) +>b : Symbol(b, Decl(a.ts, 88, 39)) >undefined : Symbol(undefined) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a33: { a: number; }[] = a32; ->a33 : Symbol(a33, Decl(iteratorZip.ts, 91, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 91, 12)) ->a32 : Symbol(a32, Decl(iteratorZip.ts, 90, 5)) +>a33 : Symbol(a33, Decl(a.ts, 89, 5)) +>a : Symbol(a, Decl(a.ts, 89, 12)) +>a32 : Symbol(a32, Decl(a.ts, 88, 5)) a32[0].b; ->a32 : Symbol(a32, Decl(iteratorZip.ts, 90, 5)) +>a32 : Symbol(a32, Decl(a.ts, 88, 5)) const a34: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); ->a34 : Symbol(a34, Decl(iteratorZip.ts, 93, 5)) +>a34 : Symbol(a34, Decl(a.ts, 91, 5)) >Iterator.zipKeyed({ a: undefined }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 93, 40)) +>a : Symbol(a, Decl(a.ts, 91, 40)) >undefined : Symbol(undefined) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a35: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray(); ->a35 : Symbol(a35, Decl(iteratorZip.ts, 94, 5)) +>a35 : Symbol(a35, Decl(a.ts, 92, 5)) >Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 94, 40)) +>a : Symbol(a, Decl(a.ts, 92, 40)) >undefined : Symbol(undefined) ->mode : Symbol(mode, Decl(iteratorZip.ts, 94, 58)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 94, 75)) +>mode : Symbol(mode, Decl(a.ts, 92, 58)) +>padding : Symbol(padding, Decl(a.ts, 92, 75)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) interface I2 { ->I2 : Symbol(I2, Decl(iteratorZip.ts, 94, 101)) +>I2 : Symbol(I2, Decl(a.ts, 92, 101)) readonly a: Iterable; ->a : Symbol(I2.a, Decl(iteratorZip.ts, 96, 14)) +>a : Symbol(I2.a, Decl(a.ts, 94, 14)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) readonly b?: Iterator; ->b : Symbol(I2.b, Decl(iteratorZip.ts, 97, 33)) +>b : Symbol(I2.b, Decl(a.ts, 95, 33)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) readonly c: Iterable | undefined; ->c : Symbol(I2.c, Decl(iteratorZip.ts, 98, 34)) +>c : Symbol(I2.c, Decl(a.ts, 96, 34)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) readonly d?: undefined; ->d : Symbol(I2.d, Decl(iteratorZip.ts, 99, 46)) +>d : Symbol(I2.d, Decl(a.ts, 97, 46)) } declare const a36: I2; ->a36 : Symbol(a36, Decl(iteratorZip.ts, 102, 13)) ->I2 : Symbol(I2, Decl(iteratorZip.ts, 94, 101)) +>a36 : Symbol(a36, Decl(a.ts, 100, 13)) +>I2 : Symbol(I2, Decl(a.ts, 92, 101)) const a37 = Iterator.zipKeyed(a36).toArray(); ->a37 : Symbol(a37, Decl(iteratorZip.ts, 103, 5)) +>a37 : Symbol(a37, Decl(a.ts, 101, 5)) >Iterator.zipKeyed(a36).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a36 : Symbol(a36, Decl(iteratorZip.ts, 102, 13)) +>a36 : Symbol(a36, Decl(a.ts, 100, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a38: { a: number; b?: string; c?: boolean; }[] = a37; ->a38 : Symbol(a38, Decl(iteratorZip.ts, 104, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 104, 12)) ->b : Symbol(b, Decl(iteratorZip.ts, 104, 23)) ->c : Symbol(c, Decl(iteratorZip.ts, 104, 35)) ->a37 : Symbol(a37, Decl(iteratorZip.ts, 103, 5)) +>a38 : Symbol(a38, Decl(a.ts, 102, 5)) +>a : Symbol(a, Decl(a.ts, 102, 12)) +>b : Symbol(b, Decl(a.ts, 102, 23)) +>c : Symbol(c, Decl(a.ts, 102, 35)) +>a37 : Symbol(a37, Decl(a.ts, 101, 5)) a37[0].a = 2; ->a37[0].a : Symbol(a, Decl(iteratorZip.ts, 96, 14)) ->a37 : Symbol(a37, Decl(iteratorZip.ts, 103, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 96, 14)) +>a37[0].a : Symbol(a, Decl(a.ts, 94, 14)) +>a37 : Symbol(a37, Decl(a.ts, 101, 5)) +>a : Symbol(a, Decl(a.ts, 94, 14)) a37[0].b = "a"; ->a37[0].b : Symbol(b, Decl(iteratorZip.ts, 97, 33)) ->a37 : Symbol(a37, Decl(iteratorZip.ts, 103, 5)) ->b : Symbol(b, Decl(iteratorZip.ts, 97, 33)) +>a37[0].b : Symbol(b, Decl(a.ts, 95, 33)) +>a37 : Symbol(a37, Decl(a.ts, 101, 5)) +>b : Symbol(b, Decl(a.ts, 95, 33)) a37[0].c = true; ->a37[0].c : Symbol(c, Decl(iteratorZip.ts, 98, 34)) ->a37 : Symbol(a37, Decl(iteratorZip.ts, 103, 5)) ->c : Symbol(c, Decl(iteratorZip.ts, 98, 34)) +>a37[0].c : Symbol(c, Decl(a.ts, 96, 34)) +>a37 : Symbol(a37, Decl(a.ts, 101, 5)) +>c : Symbol(c, Decl(a.ts, 96, 34)) a37[0].d; ->a37 : Symbol(a37, Decl(iteratorZip.ts, 103, 5)) +>a37 : Symbol(a37, Decl(a.ts, 101, 5)) const a39: { a: number; c: boolean; }[] = a37; ->a39 : Symbol(a39, Decl(iteratorZip.ts, 109, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 109, 12)) ->c : Symbol(c, Decl(iteratorZip.ts, 109, 23)) ->a37 : Symbol(a37, Decl(iteratorZip.ts, 103, 5)) +>a39 : Symbol(a39, Decl(a.ts, 107, 5)) +>a : Symbol(a, Decl(a.ts, 107, 12)) +>c : Symbol(c, Decl(a.ts, 107, 23)) +>a37 : Symbol(a37, Decl(a.ts, 101, 5)) const a40: { a: number | undefined; b?: string | undefined; c?: boolean | undefined; }[] = Iterator.zipKeyed(a36, { mode: "longest" }).toArray(); ->a40 : Symbol(a40, Decl(iteratorZip.ts, 110, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 110, 12)) ->b : Symbol(b, Decl(iteratorZip.ts, 110, 35)) ->c : Symbol(c, Decl(iteratorZip.ts, 110, 59)) +>a40 : Symbol(a40, Decl(a.ts, 108, 5)) +>a : Symbol(a, Decl(a.ts, 108, 12)) +>b : Symbol(b, Decl(a.ts, 108, 35)) +>c : Symbol(c, Decl(a.ts, 108, 59)) >Iterator.zipKeyed(a36, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a36 : Symbol(a36, Decl(iteratorZip.ts, 102, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 110, 115)) +>a36 : Symbol(a36, Decl(a.ts, 100, 13)) +>mode : Symbol(mode, Decl(a.ts, 108, 115)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) declare const a41: { a: Iterable; } | { b: Iterator; }; ->a41 : Symbol(a41, Decl(iteratorZip.ts, 112, 13)) ->a : Symbol(a, Decl(iteratorZip.ts, 112, 20)) +>a41 : Symbol(a41, Decl(a.ts, 110, 13)) +>a : Symbol(a, Decl(a.ts, 110, 20)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->b : Symbol(b, Decl(iteratorZip.ts, 112, 47)) +>b : Symbol(b, Decl(a.ts, 110, 47)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) const a42: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(a41).toArray(); ->a42 : Symbol(a42, Decl(iteratorZip.ts, 113, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 113, 13)) ->b : Symbol(b, Decl(iteratorZip.ts, 113, 30)) +>a42 : Symbol(a42, Decl(a.ts, 111, 5)) +>a : Symbol(a, Decl(a.ts, 111, 13)) +>b : Symbol(b, Decl(a.ts, 111, 30)) >Iterator.zipKeyed(a41).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a41 : Symbol(a41, Decl(iteratorZip.ts, 112, 13)) +>a41 : Symbol(a41, Decl(a.ts, 110, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) declare const a43: { a: Iterable; } | { b: number; }; ->a43 : Symbol(a43, Decl(iteratorZip.ts, 114, 13)) ->a : Symbol(a, Decl(iteratorZip.ts, 114, 20)) +>a43 : Symbol(a43, Decl(a.ts, 112, 13)) +>a : Symbol(a, Decl(a.ts, 112, 20)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->b : Symbol(b, Decl(iteratorZip.ts, 114, 47)) +>b : Symbol(b, Decl(a.ts, 112, 47)) Iterator.zipKeyed(a43); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a43 : Symbol(a43, Decl(iteratorZip.ts, 114, 13)) +>a43 : Symbol(a43, Decl(a.ts, 112, 13)) Iterator.zipKeyed(a43, { mode: "longest" }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a43 : Symbol(a43, Decl(iteratorZip.ts, 114, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 116, 24)) +>a43 : Symbol(a43, Decl(a.ts, 112, 13)) +>mode : Symbol(mode, Decl(a.ts, 114, 24)) Iterator.zipKeyed(a43, { mode: "longest", padding: {} }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a43 : Symbol(a43, Decl(iteratorZip.ts, 114, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 117, 24)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 117, 41)) +>a43 : Symbol(a43, Decl(a.ts, 112, 13)) +>mode : Symbol(mode, Decl(a.ts, 115, 24)) +>padding : Symbol(padding, Decl(a.ts, 115, 41)) declare const a44: { a?: Iterable; } | { b: string; }; ->a44 : Symbol(a44, Decl(iteratorZip.ts, 118, 13)) ->a : Symbol(a, Decl(iteratorZip.ts, 118, 20)) +>a44 : Symbol(a44, Decl(a.ts, 116, 13)) +>a : Symbol(a, Decl(a.ts, 116, 20)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->b : Symbol(b, Decl(iteratorZip.ts, 118, 48)) +>b : Symbol(b, Decl(a.ts, 116, 48)) Iterator.zipKeyed(a44); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a44 : Symbol(a44, Decl(iteratorZip.ts, 118, 13)) +>a44 : Symbol(a44, Decl(a.ts, 116, 13)) declare const a45: { a: Iterable; } | { b: undefined; }; ->a45 : Symbol(a45, Decl(iteratorZip.ts, 120, 13)) ->a : Symbol(a, Decl(iteratorZip.ts, 120, 20)) +>a45 : Symbol(a45, Decl(a.ts, 118, 13)) +>a : Symbol(a, Decl(a.ts, 118, 20)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->b : Symbol(b, Decl(iteratorZip.ts, 120, 47)) +>b : Symbol(b, Decl(a.ts, 118, 47)) const a46: { a: number; }[] = Iterator.zipKeyed(a45).toArray(); ->a46 : Symbol(a46, Decl(iteratorZip.ts, 121, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 121, 12)) +>a46 : Symbol(a46, Decl(a.ts, 119, 5)) +>a : Symbol(a, Decl(a.ts, 119, 12)) >Iterator.zipKeyed(a45).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a45 : Symbol(a45, Decl(iteratorZip.ts, 120, 13)) +>a45 : Symbol(a45, Decl(a.ts, 118, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) declare const a47: unique symbol; ->a47 : Symbol(a47, Decl(iteratorZip.ts, 123, 13)) +>a47 : Symbol(a47, Decl(a.ts, 121, 13)) declare const a48: { a: Iterable; [a47]?: Iterable; }; ->a48 : Symbol(a48, Decl(iteratorZip.ts, 124, 13)) ->a : Symbol(a, Decl(iteratorZip.ts, 124, 20)) +>a48 : Symbol(a48, Decl(a.ts, 122, 13)) +>a : Symbol(a, Decl(a.ts, 122, 20)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->[a47] : Symbol([a47], Decl(iteratorZip.ts, 124, 41)) ->a47 : Symbol(a47, Decl(iteratorZip.ts, 123, 13)) +>[a47] : Symbol([a47], Decl(a.ts, 122, 41)) +>a47 : Symbol(a47, Decl(a.ts, 121, 13)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) const a49: { a: number; [a47]?: string; }[] = Iterator.zipKeyed(a48).toArray(); ->a49 : Symbol(a49, Decl(iteratorZip.ts, 125, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 125, 12)) ->[a47] : Symbol([a47], Decl(iteratorZip.ts, 125, 23)) ->a47 : Symbol(a47, Decl(iteratorZip.ts, 123, 13)) +>a49 : Symbol(a49, Decl(a.ts, 123, 5)) +>a : Symbol(a, Decl(a.ts, 123, 12)) +>[a47] : Symbol([a47], Decl(a.ts, 123, 23)) +>a47 : Symbol(a47, Decl(a.ts, 121, 13)) >Iterator.zipKeyed(a48).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a48 : Symbol(a48, Decl(iteratorZip.ts, 124, 13)) +>a48 : Symbol(a48, Decl(a.ts, 122, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) Iterator.zipKeyed({ a: [1], b: null }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 127, 19)) ->b : Symbol(b, Decl(iteratorZip.ts, 127, 27)) +>a : Symbol(a, Decl(a.ts, 125, 19)) +>b : Symbol(b, Decl(a.ts, 125, 27)) Iterator.zipKeyed({ a: [1], b: false }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 128, 19)) ->b : Symbol(b, Decl(iteratorZip.ts, 128, 27)) +>a : Symbol(a, Decl(a.ts, 126, 19)) +>b : Symbol(b, Decl(a.ts, 126, 27)) Iterator.zip([undefined]); >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) @@ -675,585 +667,585 @@ Iterator.zip([undefined]); >undefined : Symbol(undefined) declare const a50: { a?: undefined; }; ->a50 : Symbol(a50, Decl(iteratorZip.ts, 131, 13)) ->a : Symbol(a, Decl(iteratorZip.ts, 131, 20)) +>a50 : Symbol(a50, Decl(a.ts, 129, 13)) +>a : Symbol(a, Decl(a.ts, 129, 20)) const a51: never[] = Iterator.zipKeyed(a50).toArray(); ->a51 : Symbol(a51, Decl(iteratorZip.ts, 132, 5)) +>a51 : Symbol(a51, Decl(a.ts, 130, 5)) >Iterator.zipKeyed(a50).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a50 : Symbol(a50, Decl(iteratorZip.ts, 131, 13)) +>a50 : Symbol(a50, Decl(a.ts, 129, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a52: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray(); ->a52 : Symbol(a52, Decl(iteratorZip.ts, 133, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 133, 12)) +>a52 : Symbol(a52, Decl(a.ts, 131, 5)) +>a : Symbol(a, Decl(a.ts, 131, 12)) >Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 133, 49)) ->b : Symbol(b, Decl(iteratorZip.ts, 133, 57)) +>a : Symbol(a, Decl(a.ts, 131, 49)) +>b : Symbol(b, Decl(a.ts, 131, 57)) >undefined : Symbol(undefined) ->mode : Symbol(mode, Decl(iteratorZip.ts, 133, 75)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 133, 92)) ->a : Symbol(a, Decl(iteratorZip.ts, 133, 103)) +>mode : Symbol(mode, Decl(a.ts, 131, 75)) +>padding : Symbol(padding, Decl(a.ts, 131, 92)) +>a : Symbol(a, Decl(a.ts, 131, 103)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a53: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray(); ->a53 : Symbol(a53, Decl(iteratorZip.ts, 134, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 134, 12)) +>a53 : Symbol(a53, Decl(a.ts, 132, 5)) +>a : Symbol(a, Decl(a.ts, 132, 12)) >Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 134, 61)) ->b : Symbol(b, Decl(iteratorZip.ts, 134, 69)) +>a : Symbol(a, Decl(a.ts, 132, 61)) +>b : Symbol(b, Decl(a.ts, 132, 69)) >undefined : Symbol(undefined) ->mode : Symbol(mode, Decl(iteratorZip.ts, 134, 87)) +>mode : Symbol(mode, Decl(a.ts, 132, 87)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) function f1(a: Iterable) { ->f1 : Symbol(f1, Decl(iteratorZip.ts, 134, 117)) ->T : Symbol(T, Decl(iteratorZip.ts, 136, 12)) ->a : Symbol(a, Decl(iteratorZip.ts, 136, 15)) +>f1 : Symbol(f1, Decl(a.ts, 132, 117)) +>T : Symbol(T, Decl(a.ts, 134, 12)) +>a : Symbol(a, Decl(a.ts, 134, 15)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->T : Symbol(T, Decl(iteratorZip.ts, 136, 12)) +>T : Symbol(T, Decl(a.ts, 134, 12)) const b: { a: T; }[] = Iterator.zipKeyed({ a }).toArray(); ->b : Symbol(b, Decl(iteratorZip.ts, 137, 9)) ->a : Symbol(a, Decl(iteratorZip.ts, 137, 14)) ->T : Symbol(T, Decl(iteratorZip.ts, 136, 12)) +>b : Symbol(b, Decl(a.ts, 135, 9)) +>a : Symbol(a, Decl(a.ts, 135, 14)) +>T : Symbol(T, Decl(a.ts, 134, 12)) >Iterator.zipKeyed({ a }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 137, 46)) +>a : Symbol(a, Decl(a.ts, 135, 46)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const c: [T][] = Iterator.zip([a]).toArray(); ->c : Symbol(c, Decl(iteratorZip.ts, 138, 9)) ->T : Symbol(T, Decl(iteratorZip.ts, 136, 12)) +>c : Symbol(c, Decl(a.ts, 136, 9)) +>T : Symbol(T, Decl(a.ts, 134, 12)) >Iterator.zip([a]).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->a : Symbol(a, Decl(iteratorZip.ts, 136, 15)) +>a : Symbol(a, Decl(a.ts, 134, 15)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) return { b, c }; ->b : Symbol(b, Decl(iteratorZip.ts, 139, 12)) ->c : Symbol(c, Decl(iteratorZip.ts, 139, 15)) +>b : Symbol(b, Decl(a.ts, 137, 12)) +>c : Symbol(c, Decl(a.ts, 137, 15)) } const a54: [Iterable, ...Iterable[]] = [[1, 2], [3]]; ->a54 : Symbol(a54, Decl(iteratorZip.ts, 142, 5)) +>a54 : Symbol(a54, Decl(a.ts, 140, 5)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) const a55 = Iterator.zip(a54, { mode: "longest", padding: [0] }).toArray(); ->a55 : Symbol(a55, Decl(iteratorZip.ts, 143, 5)) +>a55 : Symbol(a55, Decl(a.ts, 141, 5)) >Iterator.zip(a54, { mode: "longest", padding: [0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->a54 : Symbol(a54, Decl(iteratorZip.ts, 142, 5)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 143, 31)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 143, 48)) +>a54 : Symbol(a54, Decl(a.ts, 140, 5)) +>mode : Symbol(mode, Decl(a.ts, 141, 31)) +>padding : Symbol(padding, Decl(a.ts, 141, 48)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a56: (number | undefined)[][] = a55; ->a56 : Symbol(a56, Decl(iteratorZip.ts, 144, 5)) ->a55 : Symbol(a55, Decl(iteratorZip.ts, 143, 5)) +>a56 : Symbol(a56, Decl(a.ts, 142, 5)) +>a55 : Symbol(a55, Decl(a.ts, 141, 5)) const a57: number[][] = a55; ->a57 : Symbol(a57, Decl(iteratorZip.ts, 145, 5)) ->a55 : Symbol(a55, Decl(iteratorZip.ts, 143, 5)) +>a57 : Symbol(a57, Decl(a.ts, 143, 5)) +>a55 : Symbol(a55, Decl(a.ts, 141, 5)) const a58: Record> = { a: [1], b: [2, 3] }; ->a58 : Symbol(a58, Decl(iteratorZip.ts, 147, 5)) +>a58 : Symbol(a58, Decl(a.ts, 145, 5)) >Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 147, 47)) ->b : Symbol(b, Decl(iteratorZip.ts, 147, 55)) +>a : Symbol(a, Decl(a.ts, 145, 47)) +>b : Symbol(b, Decl(a.ts, 145, 55)) const a59 = Iterator.zipKeyed(a58, { mode: "longest", padding: {} }).toArray(); ->a59 : Symbol(a59, Decl(iteratorZip.ts, 148, 5)) +>a59 : Symbol(a59, Decl(a.ts, 146, 5)) >Iterator.zipKeyed(a58, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a58 : Symbol(a58, Decl(iteratorZip.ts, 147, 5)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 148, 36)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 148, 53)) +>a58 : Symbol(a58, Decl(a.ts, 145, 5)) +>mode : Symbol(mode, Decl(a.ts, 146, 36)) +>padding : Symbol(padding, Decl(a.ts, 146, 53)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a60: Record[] = a59; ->a60 : Symbol(a60, Decl(iteratorZip.ts, 149, 5)) +>a60 : Symbol(a60, Decl(a.ts, 147, 5)) >Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) ->a59 : Symbol(a59, Decl(iteratorZip.ts, 148, 5)) +>a59 : Symbol(a59, Decl(a.ts, 146, 5)) const a61: Record[] = a59; ->a61 : Symbol(a61, Decl(iteratorZip.ts, 150, 5)) +>a61 : Symbol(a61, Decl(a.ts, 148, 5)) >Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) ->a59 : Symbol(a59, Decl(iteratorZip.ts, 148, 5)) +>a59 : Symbol(a59, Decl(a.ts, 146, 5)) declare const a62: Record; ->a62 : Symbol(a62, Decl(iteratorZip.ts, 152, 13)) +>a62 : Symbol(a62, Decl(a.ts, 150, 13)) >Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) const a63 = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a62 }).toArray(); ->a63 : Symbol(a63, Decl(iteratorZip.ts, 153, 5)) +>a63 : Symbol(a63, Decl(a.ts, 151, 5)) >Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a62 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 153, 31)) ->b : Symbol(b, Decl(iteratorZip.ts, 153, 39)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 153, 54)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 153, 71)) ->a62 : Symbol(a62, Decl(iteratorZip.ts, 152, 13)) +>a : Symbol(a, Decl(a.ts, 151, 31)) +>b : Symbol(b, Decl(a.ts, 151, 39)) +>mode : Symbol(mode, Decl(a.ts, 151, 54)) +>padding : Symbol(padding, Decl(a.ts, 151, 71)) +>a62 : Symbol(a62, Decl(a.ts, 150, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a64: { a: number | undefined; b: number | undefined; }[] = a63; ->a64 : Symbol(a64, Decl(iteratorZip.ts, 154, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 154, 12)) ->b : Symbol(b, Decl(iteratorZip.ts, 154, 35)) ->a63 : Symbol(a63, Decl(iteratorZip.ts, 153, 5)) +>a64 : Symbol(a64, Decl(a.ts, 152, 5)) +>a : Symbol(a, Decl(a.ts, 152, 12)) +>b : Symbol(b, Decl(a.ts, 152, 35)) +>a63 : Symbol(a63, Decl(a.ts, 151, 5)) const a65: { a: number; b: number; }[] = a63; ->a65 : Symbol(a65, Decl(iteratorZip.ts, 155, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 155, 12)) ->b : Symbol(b, Decl(iteratorZip.ts, 155, 23)) ->a63 : Symbol(a63, Decl(iteratorZip.ts, 153, 5)) +>a65 : Symbol(a65, Decl(a.ts, 153, 5)) +>a : Symbol(a, Decl(a.ts, 153, 12)) +>b : Symbol(b, Decl(a.ts, 153, 23)) +>a63 : Symbol(a63, Decl(a.ts, 151, 5)) const a66 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); ->a66 : Symbol(a66, Decl(iteratorZip.ts, 157, 5)) +>a66 : Symbol(a66, Decl(a.ts, 155, 5)) >Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 157, 40)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 157, 57)) +>mode : Symbol(mode, Decl(a.ts, 155, 40)) +>padding : Symbol(padding, Decl(a.ts, 155, 57)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a67: [number, string][] = a66; ->a67 : Symbol(a67, Decl(iteratorZip.ts, 158, 5)) ->a66 : Symbol(a66, Decl(iteratorZip.ts, 157, 5)) +>a67 : Symbol(a67, Decl(a.ts, 156, 5)) +>a66 : Symbol(a66, Decl(a.ts, 155, 5)) const a68 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray(); ->a68 : Symbol(a68, Decl(iteratorZip.ts, 159, 5)) +>a68 : Symbol(a68, Decl(a.ts, 157, 5)) >Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 159, 31)) ->b : Symbol(b, Decl(iteratorZip.ts, 159, 39)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 159, 53)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 159, 70)) ->a : Symbol(a, Decl(iteratorZip.ts, 159, 81)) ->b : Symbol(b, Decl(iteratorZip.ts, 159, 87)) +>a : Symbol(a, Decl(a.ts, 157, 31)) +>b : Symbol(b, Decl(a.ts, 157, 39)) +>mode : Symbol(mode, Decl(a.ts, 157, 53)) +>padding : Symbol(padding, Decl(a.ts, 157, 70)) +>a : Symbol(a, Decl(a.ts, 157, 81)) +>b : Symbol(b, Decl(a.ts, 157, 87)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a69: { a: number; b: string; }[] = a68; ->a69 : Symbol(a69, Decl(iteratorZip.ts, 160, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 160, 12)) ->b : Symbol(b, Decl(iteratorZip.ts, 160, 23)) ->a68 : Symbol(a68, Decl(iteratorZip.ts, 159, 5)) +>a69 : Symbol(a69, Decl(a.ts, 158, 5)) +>a : Symbol(a, Decl(a.ts, 158, 12)) +>b : Symbol(b, Decl(a.ts, 158, 23)) +>a68 : Symbol(a68, Decl(a.ts, 157, 5)) const a70 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray(); ->a70 : Symbol(a70, Decl(iteratorZip.ts, 162, 5)) +>a70 : Symbol(a70, Decl(a.ts, 160, 5)) >Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 162, 40)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 162, 57)) +>mode : Symbol(mode, Decl(a.ts, 160, 40)) +>padding : Symbol(padding, Decl(a.ts, 160, 57)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a71: [number | undefined, string | undefined][] = a70; ->a71 : Symbol(a71, Decl(iteratorZip.ts, 163, 5)) ->a70 : Symbol(a70, Decl(iteratorZip.ts, 162, 5)) +>a71 : Symbol(a71, Decl(a.ts, 161, 5)) +>a70 : Symbol(a70, Decl(a.ts, 160, 5)) const a72: [number, string][] = a70; ->a72 : Symbol(a72, Decl(iteratorZip.ts, 164, 5)) ->a70 : Symbol(a70, Decl(iteratorZip.ts, 162, 5)) +>a72 : Symbol(a72, Decl(a.ts, 162, 5)) +>a70 : Symbol(a70, Decl(a.ts, 160, 5)) const a73 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray(); ->a73 : Symbol(a73, Decl(iteratorZip.ts, 165, 5)) +>a73 : Symbol(a73, Decl(a.ts, 163, 5)) >Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 165, 31)) ->b : Symbol(b, Decl(iteratorZip.ts, 165, 39)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 165, 53)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 165, 70)) ->a : Symbol(a, Decl(iteratorZip.ts, 165, 81)) +>a : Symbol(a, Decl(a.ts, 163, 31)) +>b : Symbol(b, Decl(a.ts, 163, 39)) +>mode : Symbol(mode, Decl(a.ts, 163, 53)) +>padding : Symbol(padding, Decl(a.ts, 163, 70)) +>a : Symbol(a, Decl(a.ts, 163, 81)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a74: { a: number | undefined; b: string | undefined; }[] = a73; ->a74 : Symbol(a74, Decl(iteratorZip.ts, 166, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 166, 12)) ->b : Symbol(b, Decl(iteratorZip.ts, 166, 35)) ->a73 : Symbol(a73, Decl(iteratorZip.ts, 165, 5)) +>a74 : Symbol(a74, Decl(a.ts, 164, 5)) +>a : Symbol(a, Decl(a.ts, 164, 12)) +>b : Symbol(b, Decl(a.ts, 164, 35)) +>a73 : Symbol(a73, Decl(a.ts, 163, 5)) const a75: { a: number; b: string; }[] = a73; ->a75 : Symbol(a75, Decl(iteratorZip.ts, 167, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 167, 12)) ->b : Symbol(b, Decl(iteratorZip.ts, 167, 23)) ->a73 : Symbol(a73, Decl(iteratorZip.ts, 165, 5)) +>a75 : Symbol(a75, Decl(a.ts, 165, 5)) +>a : Symbol(a, Decl(a.ts, 165, 12)) +>b : Symbol(b, Decl(a.ts, 165, 23)) +>a73 : Symbol(a73, Decl(a.ts, 163, 5)) declare const a76: readonly [number, string]; ->a76 : Symbol(a76, Decl(iteratorZip.ts, 169, 13)) +>a76 : Symbol(a76, Decl(a.ts, 167, 13)) const a77: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a76 }).toArray(); ->a77 : Symbol(a77, Decl(iteratorZip.ts, 170, 5)) +>a77 : Symbol(a77, Decl(a.ts, 168, 5)) >Iterator.zip([[1], ["a"]], { mode: "longest", padding: a76 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 170, 60)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 170, 77)) ->a76 : Symbol(a76, Decl(iteratorZip.ts, 169, 13)) +>mode : Symbol(mode, Decl(a.ts, 168, 60)) +>padding : Symbol(padding, Decl(a.ts, 168, 77)) +>a76 : Symbol(a76, Decl(a.ts, 167, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) declare const a78: [number, string?]; ->a78 : Symbol(a78, Decl(iteratorZip.ts, 171, 13)) +>a78 : Symbol(a78, Decl(a.ts, 169, 13)) const a79 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a78 }).toArray(); ->a79 : Symbol(a79, Decl(iteratorZip.ts, 172, 5)) +>a79 : Symbol(a79, Decl(a.ts, 170, 5)) >Iterator.zip([[1], ["a"]], { mode: "longest", padding: a78 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 172, 40)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 172, 57)) ->a78 : Symbol(a78, Decl(iteratorZip.ts, 171, 13)) +>mode : Symbol(mode, Decl(a.ts, 170, 40)) +>padding : Symbol(padding, Decl(a.ts, 170, 57)) +>a78 : Symbol(a78, Decl(a.ts, 169, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a80: [number, string][] = a79; ->a80 : Symbol(a80, Decl(iteratorZip.ts, 173, 5)) ->a79 : Symbol(a79, Decl(iteratorZip.ts, 172, 5)) +>a80 : Symbol(a80, Decl(a.ts, 171, 5)) +>a79 : Symbol(a79, Decl(a.ts, 170, 5)) declare const a81: [Iterable] | [Iterable, Iterable]; ->a81 : Symbol(a81, Decl(iteratorZip.ts, 175, 13)) +>a81 : Symbol(a81, Decl(a.ts, 173, 13)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) const a82 = Iterator.zip(a81, { mode: "longest", padding: [0] }).toArray(); ->a82 : Symbol(a82, Decl(iteratorZip.ts, 176, 5)) +>a82 : Symbol(a82, Decl(a.ts, 174, 5)) >Iterator.zip(a81, { mode: "longest", padding: [0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->a81 : Symbol(a81, Decl(iteratorZip.ts, 175, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 176, 31)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 176, 48)) +>a81 : Symbol(a81, Decl(a.ts, 173, 13)) +>mode : Symbol(mode, Decl(a.ts, 174, 31)) +>padding : Symbol(padding, Decl(a.ts, 174, 48)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a83: number[][] = a82; ->a83 : Symbol(a83, Decl(iteratorZip.ts, 177, 5)) ->a82 : Symbol(a82, Decl(iteratorZip.ts, 176, 5)) +>a83 : Symbol(a83, Decl(a.ts, 175, 5)) +>a82 : Symbol(a82, Decl(a.ts, 174, 5)) declare const a84: { a: Iterable; } | { b: Iterable; }; ->a84 : Symbol(a84, Decl(iteratorZip.ts, 178, 13)) ->a : Symbol(a, Decl(iteratorZip.ts, 178, 20)) +>a84 : Symbol(a84, Decl(a.ts, 176, 13)) +>a : Symbol(a, Decl(a.ts, 176, 20)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->b : Symbol(b, Decl(iteratorZip.ts, 178, 47)) +>b : Symbol(b, Decl(a.ts, 176, 47)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) const a85 = Iterator.zipKeyed(a84, { mode: "longest", padding: { a: 0 } }).toArray(); ->a85 : Symbol(a85, Decl(iteratorZip.ts, 179, 5)) +>a85 : Symbol(a85, Decl(a.ts, 177, 5)) >Iterator.zipKeyed(a84, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a84 : Symbol(a84, Decl(iteratorZip.ts, 178, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 179, 36)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 179, 53)) ->a : Symbol(a, Decl(iteratorZip.ts, 179, 64)) +>a84 : Symbol(a84, Decl(a.ts, 176, 13)) +>mode : Symbol(mode, Decl(a.ts, 177, 36)) +>padding : Symbol(padding, Decl(a.ts, 177, 53)) +>a : Symbol(a, Decl(a.ts, 177, 64)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a86: ({ a: number; } | { b: string; })[] = a85; ->a86 : Symbol(a86, Decl(iteratorZip.ts, 180, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 180, 13)) ->b : Symbol(b, Decl(iteratorZip.ts, 180, 30)) ->a85 : Symbol(a85, Decl(iteratorZip.ts, 179, 5)) +>a86 : Symbol(a86, Decl(a.ts, 178, 5)) +>a : Symbol(a, Decl(a.ts, 178, 13)) +>b : Symbol(b, Decl(a.ts, 178, 30)) +>a85 : Symbol(a85, Decl(a.ts, 177, 5)) declare const a87: { a: number; } | { b: string; }; ->a87 : Symbol(a87, Decl(iteratorZip.ts, 182, 13)) ->a : Symbol(a, Decl(iteratorZip.ts, 182, 20)) ->b : Symbol(b, Decl(iteratorZip.ts, 182, 37)) +>a87 : Symbol(a87, Decl(a.ts, 180, 13)) +>a : Symbol(a, Decl(a.ts, 180, 20)) +>b : Symbol(b, Decl(a.ts, 180, 37)) const a88 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: a87 }).toArray(); ->a88 : Symbol(a88, Decl(iteratorZip.ts, 183, 5)) +>a88 : Symbol(a88, Decl(a.ts, 181, 5)) >Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: a87 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 183, 31)) ->b : Symbol(b, Decl(iteratorZip.ts, 183, 39)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 183, 53)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 183, 70)) ->a87 : Symbol(a87, Decl(iteratorZip.ts, 182, 13)) +>a : Symbol(a, Decl(a.ts, 181, 31)) +>b : Symbol(b, Decl(a.ts, 181, 39)) +>mode : Symbol(mode, Decl(a.ts, 181, 53)) +>padding : Symbol(padding, Decl(a.ts, 181, 70)) +>a87 : Symbol(a87, Decl(a.ts, 180, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a89: { a: number; b: string; }[] = a88; ->a89 : Symbol(a89, Decl(iteratorZip.ts, 184, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 184, 12)) ->b : Symbol(b, Decl(iteratorZip.ts, 184, 23)) ->a88 : Symbol(a88, Decl(iteratorZip.ts, 183, 5)) +>a89 : Symbol(a89, Decl(a.ts, 182, 5)) +>a : Symbol(a, Decl(a.ts, 182, 12)) +>b : Symbol(b, Decl(a.ts, 182, 23)) +>a88 : Symbol(a88, Decl(a.ts, 181, 5)) const a90 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray(); ->a90 : Symbol(a90, Decl(iteratorZip.ts, 186, 5)) +>a90 : Symbol(a90, Decl(a.ts, 184, 5)) >Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 186, 31)) ->b : Symbol(b, Decl(iteratorZip.ts, 186, 39)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 186, 51)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 186, 68)) ->a : Symbol(a, Decl(iteratorZip.ts, 186, 79)) +>a : Symbol(a, Decl(a.ts, 184, 31)) +>b : Symbol(b, Decl(a.ts, 184, 39)) +>mode : Symbol(mode, Decl(a.ts, 184, 51)) +>padding : Symbol(padding, Decl(a.ts, 184, 68)) +>a : Symbol(a, Decl(a.ts, 184, 79)) >undefined : Symbol(undefined) ->b : Symbol(b, Decl(iteratorZip.ts, 186, 93)) +>b : Symbol(b, Decl(a.ts, 184, 93)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a91: { a: number; b: number; }[] = a90; ->a91 : Symbol(a91, Decl(iteratorZip.ts, 187, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 187, 12)) ->b : Symbol(b, Decl(iteratorZip.ts, 187, 23)) ->a90 : Symbol(a90, Decl(iteratorZip.ts, 186, 5)) +>a91 : Symbol(a91, Decl(a.ts, 185, 5)) +>a : Symbol(a, Decl(a.ts, 185, 12)) +>b : Symbol(b, Decl(a.ts, 185, 23)) +>a90 : Symbol(a90, Decl(a.ts, 184, 5)) declare const a92: { [K in `a${string}`]: Iterable; }; ->a92 : Symbol(a92, Decl(iteratorZip.ts, 189, 13)) ->K : Symbol(K, Decl(iteratorZip.ts, 189, 22)) +>a92 : Symbol(a92, Decl(a.ts, 187, 13)) +>K : Symbol(K, Decl(a.ts, 187, 22)) >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) const a93 = Iterator.zipKeyed(a92, { mode: "longest", padding: {} }).toArray(); ->a93 : Symbol(a93, Decl(iteratorZip.ts, 190, 5)) +>a93 : Symbol(a93, Decl(a.ts, 188, 5)) >Iterator.zipKeyed(a92, { mode: "longest", padding: {} }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a92 : Symbol(a92, Decl(iteratorZip.ts, 189, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 190, 36)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 190, 53)) +>a92 : Symbol(a92, Decl(a.ts, 187, 13)) +>mode : Symbol(mode, Decl(a.ts, 188, 36)) +>padding : Symbol(padding, Decl(a.ts, 188, 53)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a94: { [K in `a${string}`]: number; }[] = a93; ->a94 : Symbol(a94, Decl(iteratorZip.ts, 191, 5)) ->K : Symbol(K, Decl(iteratorZip.ts, 191, 14)) ->a93 : Symbol(a93, Decl(iteratorZip.ts, 190, 5)) +>a94 : Symbol(a94, Decl(a.ts, 189, 5)) +>K : Symbol(K, Decl(a.ts, 189, 14)) +>a93 : Symbol(a93, Decl(a.ts, 188, 5)) declare const a95: unique symbol; ->a95 : Symbol(a95, Decl(iteratorZip.ts, 193, 13)) +>a95 : Symbol(a95, Decl(a.ts, 191, 13)) const a96: { [a95]: number; }[] = Iterator.zipKeyed({ [a95]: [1] }, { mode: "longest", padding: { [a95]: 0 } }).toArray(); ->a96 : Symbol(a96, Decl(iteratorZip.ts, 194, 5)) ->[a95] : Symbol([a95], Decl(iteratorZip.ts, 194, 12)) ->a95 : Symbol(a95, Decl(iteratorZip.ts, 193, 13)) +>a96 : Symbol(a96, Decl(a.ts, 192, 5)) +>[a95] : Symbol([a95], Decl(a.ts, 192, 12)) +>a95 : Symbol(a95, Decl(a.ts, 191, 13)) >Iterator.zipKeyed({ [a95]: [1] }, { mode: "longest", padding: { [a95]: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->[a95] : Symbol([a95], Decl(iteratorZip.ts, 194, 53)) ->a95 : Symbol(a95, Decl(iteratorZip.ts, 193, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 194, 69)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 194, 86)) ->[a95] : Symbol([a95], Decl(iteratorZip.ts, 194, 97)) ->a95 : Symbol(a95, Decl(iteratorZip.ts, 193, 13)) +>[a95] : Symbol([a95], Decl(a.ts, 192, 53)) +>a95 : Symbol(a95, Decl(a.ts, 191, 13)) +>mode : Symbol(mode, Decl(a.ts, 192, 69)) +>padding : Symbol(padding, Decl(a.ts, 192, 86)) +>[a95] : Symbol([a95], Decl(a.ts, 192, 97)) +>a95 : Symbol(a95, Decl(a.ts, 191, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) declare const a97: Record & { a: number; }; ->a97 : Symbol(a97, Decl(iteratorZip.ts, 196, 13)) +>a97 : Symbol(a97, Decl(a.ts, 194, 13)) >Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 196, 45)) +>a : Symbol(a, Decl(a.ts, 194, 45)) const a98 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: a97 }).toArray(); ->a98 : Symbol(a98, Decl(iteratorZip.ts, 197, 5)) +>a98 : Symbol(a98, Decl(a.ts, 195, 5)) >Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: a97 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 197, 31)) ->b : Symbol(b, Decl(iteratorZip.ts, 197, 39)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 197, 51)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 197, 68)) ->a97 : Symbol(a97, Decl(iteratorZip.ts, 196, 13)) +>a : Symbol(a, Decl(a.ts, 195, 31)) +>b : Symbol(b, Decl(a.ts, 195, 39)) +>mode : Symbol(mode, Decl(a.ts, 195, 51)) +>padding : Symbol(padding, Decl(a.ts, 195, 68)) +>a97 : Symbol(a97, Decl(a.ts, 194, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a99: { a: number; b: number | undefined; }[] = a98; ->a99 : Symbol(a99, Decl(iteratorZip.ts, 198, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 198, 12)) ->b : Symbol(b, Decl(iteratorZip.ts, 198, 23)) ->a98 : Symbol(a98, Decl(iteratorZip.ts, 197, 5)) +>a99 : Symbol(a99, Decl(a.ts, 196, 5)) +>a : Symbol(a, Decl(a.ts, 196, 12)) +>b : Symbol(b, Decl(a.ts, 196, 23)) +>a98 : Symbol(a98, Decl(a.ts, 195, 5)) const a100: { a: number; b: number; }[] = a98; ->a100 : Symbol(a100, Decl(iteratorZip.ts, 199, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 199, 13)) ->b : Symbol(b, Decl(iteratorZip.ts, 199, 24)) ->a98 : Symbol(a98, Decl(iteratorZip.ts, 197, 5)) +>a100 : Symbol(a100, Decl(a.ts, 197, 5)) +>a : Symbol(a, Decl(a.ts, 197, 13)) +>b : Symbol(b, Decl(a.ts, 197, 24)) +>a98 : Symbol(a98, Decl(a.ts, 195, 5)) declare const a101: [number] | [number, string]; ->a101 : Symbol(a101, Decl(iteratorZip.ts, 201, 13)) +>a101 : Symbol(a101, Decl(a.ts, 199, 13)) const a102 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a101 }).toArray(); ->a102 : Symbol(a102, Decl(iteratorZip.ts, 202, 5)) +>a102 : Symbol(a102, Decl(a.ts, 200, 5)) >Iterator.zip([[1], ["a"]], { mode: "longest", padding: a101 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 202, 41)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 202, 58)) ->a101 : Symbol(a101, Decl(iteratorZip.ts, 201, 13)) +>mode : Symbol(mode, Decl(a.ts, 200, 41)) +>padding : Symbol(padding, Decl(a.ts, 200, 58)) +>a101 : Symbol(a101, Decl(a.ts, 199, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a103: [number, string | undefined][] = a102; ->a103 : Symbol(a103, Decl(iteratorZip.ts, 203, 5)) ->a102 : Symbol(a102, Decl(iteratorZip.ts, 202, 5)) +>a103 : Symbol(a103, Decl(a.ts, 201, 5)) +>a102 : Symbol(a102, Decl(a.ts, 200, 5)) const a104: [number, string][] = a102; ->a104 : Symbol(a104, Decl(iteratorZip.ts, 204, 5)) ->a102 : Symbol(a102, Decl(iteratorZip.ts, 202, 5)) +>a104 : Symbol(a104, Decl(a.ts, 202, 5)) +>a102 : Symbol(a102, Decl(a.ts, 200, 5)) const a105: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray(); ->a105 : Symbol(a105, Decl(iteratorZip.ts, 206, 5)) +>a105 : Symbol(a105, Decl(a.ts, 204, 5)) >Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->mode : Symbol(mode, Decl(iteratorZip.ts, 206, 71)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 206, 88)) +>mode : Symbol(mode, Decl(a.ts, 204, 71)) +>padding : Symbol(padding, Decl(a.ts, 204, 88)) >undefined : Symbol(undefined) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a106: { a: number | undefined; b: number; }[] = a90; ->a106 : Symbol(a106, Decl(iteratorZip.ts, 207, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 207, 13)) ->b : Symbol(b, Decl(iteratorZip.ts, 207, 36)) ->a90 : Symbol(a90, Decl(iteratorZip.ts, 186, 5)) +>a106 : Symbol(a106, Decl(a.ts, 205, 5)) +>a : Symbol(a, Decl(a.ts, 205, 13)) +>b : Symbol(b, Decl(a.ts, 205, 36)) +>a90 : Symbol(a90, Decl(a.ts, 184, 5)) class C1 { ->C1 : Symbol(C1, Decl(iteratorZip.ts, 207, 58)) +>C1 : Symbol(C1, Decl(a.ts, 205, 58)) a = [1, 2]; ->a : Symbol(C1.a, Decl(iteratorZip.ts, 209, 10)) +>a : Symbol(C1.a, Decl(a.ts, 207, 10)) get b() { ->b : Symbol(C1.b, Decl(iteratorZip.ts, 210, 15)) +>b : Symbol(C1.b, Decl(a.ts, 208, 15)) return "inputs"; } f() { ->f : Symbol(C1.f, Decl(iteratorZip.ts, 214, 5)) +>f : Symbol(C1.f, Decl(a.ts, 212, 5)) return this.b; ->this.b : Symbol(C1.b, Decl(iteratorZip.ts, 210, 15)) ->this : Symbol(C1, Decl(iteratorZip.ts, 207, 58)) ->b : Symbol(C1.b, Decl(iteratorZip.ts, 210, 15)) +>this.b : Symbol(C1.b, Decl(a.ts, 208, 15)) +>this : Symbol(C1, Decl(a.ts, 205, 58)) +>b : Symbol(C1.b, Decl(a.ts, 208, 15)) } } const a107 = new C1(); ->a107 : Symbol(a107, Decl(iteratorZip.ts, 221, 5)) ->C1 : Symbol(C1, Decl(iteratorZip.ts, 207, 58)) +>a107 : Symbol(a107, Decl(a.ts, 219, 5)) +>C1 : Symbol(C1, Decl(a.ts, 205, 58)) const a108 = Iterator.zipKeyed(a107).toArray(); ->a108 : Symbol(a108, Decl(iteratorZip.ts, 222, 5)) +>a108 : Symbol(a108, Decl(a.ts, 220, 5)) >Iterator.zipKeyed(a107).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a107 : Symbol(a107, Decl(iteratorZip.ts, 221, 5)) +>a107 : Symbol(a107, Decl(a.ts, 219, 5)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a109 = Iterator.zipKeyed(a107, { mode: "strict" }).toArray(); ->a109 : Symbol(a109, Decl(iteratorZip.ts, 223, 5)) +>a109 : Symbol(a109, Decl(a.ts, 221, 5)) >Iterator.zipKeyed(a107, { mode: "strict" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a107 : Symbol(a107, Decl(iteratorZip.ts, 221, 5)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 223, 38)) +>a107 : Symbol(a107, Decl(a.ts, 219, 5)) +>mode : Symbol(mode, Decl(a.ts, 221, 38)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a110 = Iterator.zipKeyed(a107, { mode: "longest" }).toArray(); ->a110 : Symbol(a110, Decl(iteratorZip.ts, 224, 5)) +>a110 : Symbol(a110, Decl(a.ts, 222, 5)) >Iterator.zipKeyed(a107, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a107 : Symbol(a107, Decl(iteratorZip.ts, 221, 5)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 224, 38)) +>a107 : Symbol(a107, Decl(a.ts, 219, 5)) +>mode : Symbol(mode, Decl(a.ts, 222, 38)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a111 = Iterator.zipKeyed(a107, { mode: "longest", padding: { a: 0 } }).toArray(); ->a111 : Symbol(a111, Decl(iteratorZip.ts, 225, 5)) +>a111 : Symbol(a111, Decl(a.ts, 223, 5)) >Iterator.zipKeyed(a107, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a107 : Symbol(a107, Decl(iteratorZip.ts, 221, 5)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 225, 38)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 225, 55)) ->a : Symbol(a, Decl(iteratorZip.ts, 225, 66)) +>a107 : Symbol(a107, Decl(a.ts, 219, 5)) +>mode : Symbol(mode, Decl(a.ts, 223, 38)) +>padding : Symbol(padding, Decl(a.ts, 223, 55)) +>a : Symbol(a, Decl(a.ts, 223, 66)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a112 = { a: [1, 2], b: "inputs" }; ->a112 : Symbol(a112, Decl(iteratorZip.ts, 227, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 227, 14)) ->b : Symbol(b, Decl(iteratorZip.ts, 227, 25)) +>a112 : Symbol(a112, Decl(a.ts, 225, 5)) +>a : Symbol(a, Decl(a.ts, 225, 14)) +>b : Symbol(b, Decl(a.ts, 225, 25)) Object.defineProperty(a112, "b", { enumerable: false }); >Object.defineProperty : Symbol(ObjectConstructor.defineProperty, Decl(lib.es5.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) >defineProperty : Symbol(ObjectConstructor.defineProperty, Decl(lib.es5.d.ts, --, --)) ->a112 : Symbol(a112, Decl(iteratorZip.ts, 227, 5)) ->enumerable : Symbol(enumerable, Decl(iteratorZip.ts, 228, 34)) +>a112 : Symbol(a112, Decl(a.ts, 225, 5)) +>enumerable : Symbol(enumerable, Decl(a.ts, 226, 34)) const a113 = Iterator.zipKeyed(a112).toArray(); ->a113 : Symbol(a113, Decl(iteratorZip.ts, 229, 5)) +>a113 : Symbol(a113, Decl(a.ts, 227, 5)) >Iterator.zipKeyed(a112).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a112 : Symbol(a112, Decl(iteratorZip.ts, 227, 5)) +>a112 : Symbol(a112, Decl(a.ts, 225, 5)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a114 = Iterator.zipKeyed(a112, { mode: "longest", padding: { a: 0 } }).toArray(); ->a114 : Symbol(a114, Decl(iteratorZip.ts, 230, 5)) +>a114 : Symbol(a114, Decl(a.ts, 228, 5)) >Iterator.zipKeyed(a112, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a112 : Symbol(a112, Decl(iteratorZip.ts, 227, 5)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 230, 38)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 230, 55)) ->a : Symbol(a, Decl(iteratorZip.ts, 230, 66)) +>a112 : Symbol(a112, Decl(a.ts, 225, 5)) +>mode : Symbol(mode, Decl(a.ts, 228, 38)) +>padding : Symbol(padding, Decl(a.ts, 228, 55)) +>a : Symbol(a, Decl(a.ts, 228, 66)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a115 = { a: [1, 2], b: "inputs" }; ->a115 : Symbol(a115, Decl(iteratorZip.ts, 232, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 232, 14)) ->b : Symbol(b, Decl(iteratorZip.ts, 232, 25)) +>a115 : Symbol(a115, Decl(a.ts, 230, 5)) +>a : Symbol(a, Decl(a.ts, 230, 14)) +>b : Symbol(b, Decl(a.ts, 230, 25)) const a116 = Iterator.zipKeyed(a115).toArray(); ->a116 : Symbol(a116, Decl(iteratorZip.ts, 233, 5)) +>a116 : Symbol(a116, Decl(a.ts, 231, 5)) >Iterator.zipKeyed(a115).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a115 : Symbol(a115, Decl(iteratorZip.ts, 232, 5)) +>a115 : Symbol(a115, Decl(a.ts, 230, 5)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a117 = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); ->a117 : Symbol(a117, Decl(iteratorZip.ts, 235, 5)) +>a117 : Symbol(a117, Decl(a.ts, 233, 5)) >Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) @@ -1261,137 +1253,137 @@ const a117 = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a118: string = a108[0].b; ->a118 : Symbol(a118, Decl(iteratorZip.ts, 237, 5)) ->a108 : Symbol(a108, Decl(iteratorZip.ts, 222, 5)) +>a118 : Symbol(a118, Decl(a.ts, 235, 5)) +>a108 : Symbol(a108, Decl(a.ts, 220, 5)) const a119: string = a113[0].b; ->a119 : Symbol(a119, Decl(iteratorZip.ts, 238, 5)) ->a113 : Symbol(a113, Decl(iteratorZip.ts, 229, 5)) +>a119 : Symbol(a119, Decl(a.ts, 236, 5)) +>a113 : Symbol(a113, Decl(a.ts, 227, 5)) declare const a120: unique symbol; ->a120 : Symbol(a120, Decl(iteratorZip.ts, 240, 13)) +>a120 : Symbol(a120, Decl(a.ts, 238, 13)) const a121: { a: number; [a120]: string; }[] = Iterator.zipKeyed({ a: [1], [a120]: ["a"] }).toArray(); ->a121 : Symbol(a121, Decl(iteratorZip.ts, 241, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 241, 13)) ->[a120] : Symbol([a120], Decl(iteratorZip.ts, 241, 24)) ->a120 : Symbol(a120, Decl(iteratorZip.ts, 240, 13)) +>a121 : Symbol(a121, Decl(a.ts, 239, 5)) +>a : Symbol(a, Decl(a.ts, 239, 13)) +>[a120] : Symbol([a120], Decl(a.ts, 239, 24)) +>a120 : Symbol(a120, Decl(a.ts, 238, 13)) >Iterator.zipKeyed({ a: [1], [a120]: ["a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 241, 66)) ->[a120] : Symbol([a120], Decl(iteratorZip.ts, 241, 74)) ->a120 : Symbol(a120, Decl(iteratorZip.ts, 240, 13)) +>a : Symbol(a, Decl(a.ts, 239, 66)) +>[a120] : Symbol([a120], Decl(a.ts, 239, 74)) +>a120 : Symbol(a120, Decl(a.ts, 238, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a122: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1] }, { mode: "longest" }).toArray(); ->a122 : Symbol(a122, Decl(iteratorZip.ts, 242, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 242, 13)) +>a122 : Symbol(a122, Decl(a.ts, 240, 5)) +>a : Symbol(a, Decl(a.ts, 240, 13)) >Iterator.zipKeyed({ a: [1] }, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 242, 62)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 242, 74)) +>a : Symbol(a, Decl(a.ts, 240, 62)) +>mode : Symbol(mode, Decl(a.ts, 240, 74)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a123: { a: number; }[] = Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray(); ->a123 : Symbol(a123, Decl(iteratorZip.ts, 243, 5)) ->a : Symbol(a, Decl(iteratorZip.ts, 243, 13)) +>a123 : Symbol(a123, Decl(a.ts, 241, 5)) +>a : Symbol(a, Decl(a.ts, 241, 13)) >Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 243, 50)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 243, 62)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 243, 79)) ->a : Symbol(a, Decl(iteratorZip.ts, 243, 90)) +>a : Symbol(a, Decl(a.ts, 241, 50)) +>mode : Symbol(mode, Decl(a.ts, 241, 62)) +>padding : Symbol(padding, Decl(a.ts, 241, 79)) +>a : Symbol(a, Decl(a.ts, 241, 90)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) declare const a124: object; ->a124 : Symbol(a124, Decl(iteratorZip.ts, 245, 13)) +>a124 : Symbol(a124, Decl(a.ts, 243, 13)) const a125 = Iterator.zipKeyed(a124).toArray(); ->a125 : Symbol(a125, Decl(iteratorZip.ts, 246, 5)) +>a125 : Symbol(a125, Decl(a.ts, 244, 5)) >Iterator.zipKeyed(a124).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a124 : Symbol(a124, Decl(iteratorZip.ts, 245, 13)) +>a124 : Symbol(a124, Decl(a.ts, 243, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a126 = Iterator.zipKeyed(a124, { mode: "strict" }).toArray(); ->a126 : Symbol(a126, Decl(iteratorZip.ts, 247, 5)) +>a126 : Symbol(a126, Decl(a.ts, 245, 5)) >Iterator.zipKeyed(a124, { mode: "strict" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a124 : Symbol(a124, Decl(iteratorZip.ts, 245, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 247, 38)) +>a124 : Symbol(a124, Decl(a.ts, 243, 13)) +>mode : Symbol(mode, Decl(a.ts, 245, 38)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a127 = Iterator.zipKeyed(a124, { mode: "longest" }).toArray(); ->a127 : Symbol(a127, Decl(iteratorZip.ts, 248, 5)) +>a127 : Symbol(a127, Decl(a.ts, 246, 5)) >Iterator.zipKeyed(a124, { mode: "longest" }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a124 : Symbol(a124, Decl(iteratorZip.ts, 245, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 248, 38)) +>a124 : Symbol(a124, Decl(a.ts, 243, 13)) +>mode : Symbol(mode, Decl(a.ts, 246, 38)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a128 = Iterator.zipKeyed(a124, { mode: "longest", padding: { a: 0 } }).toArray(); ->a128 : Symbol(a128, Decl(iteratorZip.ts, 249, 5)) +>a128 : Symbol(a128, Decl(a.ts, 247, 5)) >Iterator.zipKeyed(a124, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a124 : Symbol(a124, Decl(iteratorZip.ts, 245, 13)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 249, 38)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 249, 55)) ->a : Symbol(a, Decl(iteratorZip.ts, 249, 66)) +>a124 : Symbol(a124, Decl(a.ts, 243, 13)) +>mode : Symbol(mode, Decl(a.ts, 247, 38)) +>padding : Symbol(padding, Decl(a.ts, 247, 55)) +>a : Symbol(a, Decl(a.ts, 247, 66)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a129: unknown = a125[0].a; ->a129 : Symbol(a129, Decl(iteratorZip.ts, 250, 5)) ->a125 : Symbol(a125, Decl(iteratorZip.ts, 246, 5)) +>a129 : Symbol(a129, Decl(a.ts, 248, 5)) +>a125 : Symbol(a125, Decl(a.ts, 244, 5)) const a130: unknown = a126[0].a; ->a130 : Symbol(a130, Decl(iteratorZip.ts, 251, 5)) ->a126 : Symbol(a126, Decl(iteratorZip.ts, 247, 5)) +>a130 : Symbol(a130, Decl(a.ts, 249, 5)) +>a126 : Symbol(a126, Decl(a.ts, 245, 5)) const a131: unknown = a127[0].a; ->a131 : Symbol(a131, Decl(iteratorZip.ts, 252, 5)) ->a127 : Symbol(a127, Decl(iteratorZip.ts, 248, 5)) +>a131 : Symbol(a131, Decl(a.ts, 250, 5)) +>a127 : Symbol(a127, Decl(a.ts, 246, 5)) const a132: unknown = a128[0].a; ->a132 : Symbol(a132, Decl(iteratorZip.ts, 253, 5)) ->a128 : Symbol(a128, Decl(iteratorZip.ts, 249, 5)) +>a132 : Symbol(a132, Decl(a.ts, 251, 5)) +>a128 : Symbol(a128, Decl(a.ts, 247, 5)) const a133: never[] = a125; ->a133 : Symbol(a133, Decl(iteratorZip.ts, 254, 5)) ->a125 : Symbol(a125, Decl(iteratorZip.ts, 246, 5)) +>a133 : Symbol(a133, Decl(a.ts, 252, 5)) +>a125 : Symbol(a125, Decl(a.ts, 244, 5)) declare const a134: {}; ->a134 : Symbol(a134, Decl(iteratorZip.ts, 256, 13)) +>a134 : Symbol(a134, Decl(a.ts, 254, 13)) const a135 = Iterator.zipKeyed(a134).toArray(); ->a135 : Symbol(a135, Decl(iteratorZip.ts, 257, 5)) +>a135 : Symbol(a135, Decl(a.ts, 255, 5)) >Iterator.zipKeyed(a134).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a134 : Symbol(a134, Decl(iteratorZip.ts, 256, 13)) +>a134 : Symbol(a134, Decl(a.ts, 254, 13)) >toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) const a136: unknown = a135[0].a; ->a136 : Symbol(a136, Decl(iteratorZip.ts, 258, 5)) ->a135 : Symbol(a135, Decl(iteratorZip.ts, 257, 5)) +>a136 : Symbol(a136, Decl(a.ts, 256, 5)) +>a135 : Symbol(a135, Decl(a.ts, 255, 5)) const a137: never[] = a135; ->a137 : Symbol(a137, Decl(iteratorZip.ts, 259, 5)) ->a135 : Symbol(a135, Decl(iteratorZip.ts, 257, 5)) +>a137 : Symbol(a137, Decl(a.ts, 257, 5)) +>a135 : Symbol(a135, Decl(a.ts, 255, 5)) Iterator.zipKeyed(0); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) @@ -1407,31 +1399,624 @@ Iterator.zipKeyed(a107, { mode: "invalid" }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a107 : Symbol(a107, Decl(iteratorZip.ts, 221, 5)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 263, 25)) +>a107 : Symbol(a107, Decl(a.ts, 219, 5)) +>mode : Symbol(mode, Decl(a.ts, 261, 25)) Iterator.zipKeyed(a107, { mode: "shortest", padding: {} }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a107 : Symbol(a107, Decl(iteratorZip.ts, 221, 5)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 264, 25)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 264, 43)) +>a107 : Symbol(a107, Decl(a.ts, 219, 5)) +>mode : Symbol(mode, Decl(a.ts, 262, 25)) +>padding : Symbol(padding, Decl(a.ts, 262, 43)) Iterator.zipKeyed(a107, { mode: "longest", padding: 0 }); >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a107 : Symbol(a107, Decl(iteratorZip.ts, 221, 5)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 265, 25)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 265, 42)) +>a107 : Symbol(a107, Decl(a.ts, 219, 5)) +>mode : Symbol(mode, Decl(a.ts, 263, 25)) +>padding : Symbol(padding, Decl(a.ts, 263, 42)) + +const a138: [number | boolean, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }).toArray(); +>a138 : Symbol(a138, Decl(a.ts, 264, 5)) +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>const : Symbol(const) +>mode : Symbol(mode, Decl(a.ts, 264, 92)) +>padding : Symbol(padding, Decl(a.ts, 264, 109)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a139: { a: number | string; b: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: { a: "a" } }).toArray(); +>a139 : Symbol(a139, Decl(a.ts, 265, 5)) +>a : Symbol(a, Decl(a.ts, 265, 13)) +>b : Symbol(b, Decl(a.ts, 265, 33)) +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: { a: "a" } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(a.ts, 265, 82)) +>b : Symbol(b, Decl(a.ts, 265, 90)) +>mode : Symbol(mode, Decl(a.ts, 265, 105)) +>padding : Symbol(padding, Decl(a.ts, 265, 122)) +>a : Symbol(a, Decl(a.ts, 265, 133)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const a140: boolean[]; +>a140 : Symbol(a140, Decl(a.ts, 267, 13)) + +const a141: [number | boolean | undefined, string | boolean | undefined][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a140 }).toArray(); +>a141 : Symbol(a141, Decl(a.ts, 268, 5)) +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: a140 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(a.ts, 268, 105)) +>padding : Symbol(padding, Decl(a.ts, 268, 122)) +>a140 : Symbol(a140, Decl(a.ts, 267, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a142 = Iterator.zip(a12, { mode: "longest", padding: new Set([false]) }).toArray(); +>a142 : Symbol(a142, Decl(a.ts, 269, 5)) +>Iterator.zip(a12, { mode: "longest", padding: new Set([false]) }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>a12 : Symbol(a12, Decl(a.ts, 21, 13)) +>mode : Symbol(mode, Decl(a.ts, 269, 32)) +>padding : Symbol(padding, Decl(a.ts, 269, 49)) +>Set : Symbol(Set, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a143: (number | boolean | undefined)[][] = a142; +>a143 : Symbol(a143, Decl(a.ts, 270, 5)) +>a142 : Symbol(a142, Decl(a.ts, 269, 5)) + +const a144: (number | undefined)[][] = a142; +>a144 : Symbol(a144, Decl(a.ts, 271, 5)) +>a142 : Symbol(a142, Decl(a.ts, 269, 5)) + +const a145: (number | boolean | undefined)[][] = Iterator.zip([[1], [2, 3]], { mode: "longest", padding: new Set([false]) }).toArray(); +>a145 : Symbol(a145, Decl(a.ts, 272, 5)) +>Iterator.zip([[1], [2, 3]], { mode: "longest", padding: new Set([false]) }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(a.ts, 272, 78)) +>padding : Symbol(padding, Decl(a.ts, 272, 95)) +>Set : Symbol(Set, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const a146: { a: boolean; } | { b: string; }; +>a146 : Symbol(a146, Decl(a.ts, 274, 13)) +>a : Symbol(a, Decl(a.ts, 274, 21)) +>b : Symbol(b, Decl(a.ts, 274, 39)) + +const a147 = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a146 }).toArray(); +>a147 : Symbol(a147, Decl(a.ts, 275, 5)) +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a146 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(a.ts, 275, 32)) +>b : Symbol(b, Decl(a.ts, 275, 40)) +>mode : Symbol(mode, Decl(a.ts, 275, 55)) +>padding : Symbol(padding, Decl(a.ts, 275, 72)) +>a146 : Symbol(a146, Decl(a.ts, 274, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a148: { a: number | boolean | undefined; b: number | string | undefined; }[] = a147; +>a148 : Symbol(a148, Decl(a.ts, 276, 5)) +>a : Symbol(a, Decl(a.ts, 276, 13)) +>b : Symbol(b, Decl(a.ts, 276, 46)) +>a147 : Symbol(a147, Decl(a.ts, 275, 5)) + +const a149: { a: number | undefined; b: number | undefined; }[] = a147; +>a149 : Symbol(a149, Decl(a.ts, 277, 5)) +>a : Symbol(a, Decl(a.ts, 277, 13)) +>b : Symbol(b, Decl(a.ts, 277, 36)) +>a147 : Symbol(a147, Decl(a.ts, 275, 5)) + +declare const a150: [boolean] | [string, string]; +>a150 : Symbol(a150, Decl(a.ts, 278, 13)) + +const a151: [number | boolean | string, number | string | undefined][] = Iterator.zip([[1], [2, 3]], { mode: "longest", padding: a150 }).toArray(); +>a151 : Symbol(a151, Decl(a.ts, 279, 5)) +>Iterator.zip([[1], [2, 3]], { mode: "longest", padding: a150 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(a.ts, 279, 102)) +>padding : Symbol(padding, Decl(a.ts, 279, 119)) +>a150 : Symbol(a150, Decl(a.ts, 278, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +declare const a152: { mode: "longest"; padding?: { a: boolean; }; }; +>a152 : Symbol(a152, Decl(a.ts, 281, 13)) +>mode : Symbol(mode, Decl(a.ts, 281, 21)) +>padding : Symbol(padding, Decl(a.ts, 281, 38)) +>a : Symbol(a, Decl(a.ts, 281, 50)) + +const a153 = Iterator.zipKeyed({ a: [1] }, a152).toArray(); +>a153 : Symbol(a153, Decl(a.ts, 282, 5)) +>Iterator.zipKeyed({ a: [1] }, a152).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(a.ts, 282, 32)) +>a152 : Symbol(a152, Decl(a.ts, 281, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a154: { a: number | boolean | undefined; }[] = a153; +>a154 : Symbol(a154, Decl(a.ts, 283, 5)) +>a : Symbol(a, Decl(a.ts, 283, 13)) +>a153 : Symbol(a153, Decl(a.ts, 282, 5)) + +const a155: { a: number | boolean; }[] = a153; +>a155 : Symbol(a155, Decl(a.ts, 284, 5)) +>a : Symbol(a, Decl(a.ts, 284, 13)) +>a153 : Symbol(a153, Decl(a.ts, 282, 5)) + +declare const a156: { mode: "shortest"; } | { mode: "longest"; padding: [boolean]; } | undefined; +>a156 : Symbol(a156, Decl(a.ts, 285, 13)) +>mode : Symbol(mode, Decl(a.ts, 285, 21)) +>mode : Symbol(mode, Decl(a.ts, 285, 45)) +>padding : Symbol(padding, Decl(a.ts, 285, 62)) + +const a157: [number | boolean | undefined][] = Iterator.zip([[1]], a156).toArray(); +>a157 : Symbol(a157, Decl(a.ts, 286, 5)) +>Iterator.zip([[1]], a156).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>a156 : Symbol(a156, Decl(a.ts, 285, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a158: [number][] = Iterator.zip([[1]], { mode: undefined }).toArray(); +>a158 : Symbol(a158, Decl(a.ts, 287, 5)) +>Iterator.zip([[1]], { mode: undefined }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>mode : Symbol(mode, Decl(a.ts, 287, 46)) +>undefined : Symbol(undefined) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a159: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: undefined }).toArray(); +>a159 : Symbol(a159, Decl(a.ts, 288, 5)) +>a : Symbol(a, Decl(a.ts, 288, 13)) +>Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: undefined }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(a.ts, 288, 62)) +>mode : Symbol(mode, Decl(a.ts, 288, 74)) +>padding : Symbol(padding, Decl(a.ts, 288, 91)) +>undefined : Symbol(undefined) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a160: { a: number | { b: string; }; [a1]: boolean | string; }[] = Iterator.zipKeyed({ a: [1], [a1]: [true, false] }, { +>a160 : Symbol(a160, Decl(a.ts, 290, 5)) +>a : Symbol(a, Decl(a.ts, 290, 13)) +>b : Symbol(b, Decl(a.ts, 290, 27)) +>[a1] : Symbol([a1], Decl(a.ts, 290, 41)) +>a1 : Symbol(a1, Decl(a.ts, 0, 13)) +>Iterator.zipKeyed({ a: [1], [a1]: [true, false] }, { mode: "longest", padding: { a: { b: "a" }, [a1]: "a" },}).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(a.ts, 290, 91)) +>[a1] : Symbol([a1], Decl(a.ts, 290, 99)) +>a1 : Symbol(a1, Decl(a.ts, 0, 13)) + + mode: "longest", +>mode : Symbol(mode, Decl(a.ts, 290, 124)) + + padding: { a: { b: "a" }, [a1]: "a" }, +>padding : Symbol(padding, Decl(a.ts, 291, 20)) +>a : Symbol(a, Decl(a.ts, 292, 14)) +>b : Symbol(b, Decl(a.ts, 292, 19)) +>[a1] : Symbol([a1], Decl(a.ts, 292, 29)) +>a1 : Symbol(a1, Decl(a.ts, 0, 13)) + +}).toArray(); +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a161: { "0": number | boolean; }[] = Iterator.zipKeyed({ "0": [1] }, { mode: "longest", padding: { 0: false } }).toArray(); +>a161 : Symbol(a161, Decl(a.ts, 294, 5)) +>"0" : Symbol("0", Decl(a.ts, 294, 13)) +>Iterator.zipKeyed({ "0": [1] }, { mode: "longest", padding: { 0: false } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>"0" : Symbol("0", Decl(a.ts, 294, 62)) +>mode : Symbol(mode, Decl(a.ts, 294, 76)) +>padding : Symbol(padding, Decl(a.ts, 294, 93)) +>0 : Symbol(0, Decl(a.ts, 294, 104)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a162: { 0: number | boolean; }[] = Iterator.zipKeyed({ 0: [1] }, { mode: "longest", padding: { "0": false } }).toArray(); +>a162 : Symbol(a162, Decl(a.ts, 295, 5)) +>0 : Symbol(0, Decl(a.ts, 295, 13)) +>Iterator.zipKeyed({ 0: [1] }, { mode: "longest", padding: { "0": false } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>0 : Symbol(0, Decl(a.ts, 295, 60)) +>mode : Symbol(mode, Decl(a.ts, 295, 72)) +>padding : Symbol(padding, Decl(a.ts, 295, 89)) +>"0" : Symbol("0", Decl(a.ts, 295, 100)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a163 = Iterator.zipKeyed({ 0: [1] }, { mode: "longest", padding: { "01": false } }).toArray(); +>a163 : Symbol(a163, Decl(a.ts, 296, 5)) +>Iterator.zipKeyed({ 0: [1] }, { mode: "longest", padding: { "01": false } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>0 : Symbol(0, Decl(a.ts, 296, 32)) +>mode : Symbol(mode, Decl(a.ts, 296, 44)) +>padding : Symbol(padding, Decl(a.ts, 296, 61)) +>"01" : Symbol("01", Decl(a.ts, 296, 72)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a164: { 0: number | undefined; }[] = a163; +>a164 : Symbol(a164, Decl(a.ts, 297, 5)) +>0 : Symbol(0, Decl(a.ts, 297, 13)) +>a163 : Symbol(a163, Decl(a.ts, 296, 5)) + +const a165: { 0: number; }[] = a163; +>a165 : Symbol(a165, Decl(a.ts, 298, 5)) +>0 : Symbol(0, Decl(a.ts, 298, 13)) +>a163 : Symbol(a163, Decl(a.ts, 296, 5)) + +declare const a166: Record; +>a166 : Symbol(a166, Decl(a.ts, 300, 13)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) + +const a167 = Iterator.zipKeyed({ NaN: [1], Infinity: [2], "-Infinity": [3] }, { mode: "longest", padding: a166 }).toArray(); +>a167 : Symbol(a167, Decl(a.ts, 301, 5)) +>Iterator.zipKeyed({ NaN: [1], Infinity: [2], "-Infinity": [3] }, { mode: "longest", padding: a166 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>NaN : Symbol(NaN, Decl(a.ts, 301, 32)) +>Infinity : Symbol(Infinity, Decl(a.ts, 301, 42)) +>"-Infinity" : Symbol("-Infinity", Decl(a.ts, 301, 57)) +>mode : Symbol(mode, Decl(a.ts, 301, 79)) +>padding : Symbol(padding, Decl(a.ts, 301, 96)) +>a166 : Symbol(a166, Decl(a.ts, 300, 13)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a168: { NaN: number | boolean | undefined; Infinity: number | boolean | undefined; "-Infinity": number | boolean | undefined; }[] = a167; +>a168 : Symbol(a168, Decl(a.ts, 302, 5)) +>NaN : Symbol(NaN, Decl(a.ts, 302, 13)) +>Infinity : Symbol(Infinity, Decl(a.ts, 302, 48)) +>"-Infinity" : Symbol("-Infinity", Decl(a.ts, 302, 88)) +>a167 : Symbol(a167, Decl(a.ts, 301, 5)) + +const a169: { NaN: number | undefined; Infinity: number | undefined; "-Infinity": number | undefined; }[] = a167; +>a169 : Symbol(a169, Decl(a.ts, 303, 5)) +>NaN : Symbol(NaN, Decl(a.ts, 303, 13)) +>Infinity : Symbol(Infinity, Decl(a.ts, 303, 38)) +>"-Infinity" : Symbol("-Infinity", Decl(a.ts, 303, 68)) +>a167 : Symbol(a167, Decl(a.ts, 301, 5)) + +const a170 = Iterator.zipKeyed(a58, { mode: "longest", padding: { a: false } }).toArray(); +>a170 : Symbol(a170, Decl(a.ts, 304, 5)) +>Iterator.zipKeyed(a58, { mode: "longest", padding: { a: false } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a58 : Symbol(a58, Decl(a.ts, 145, 5)) +>mode : Symbol(mode, Decl(a.ts, 304, 37)) +>padding : Symbol(padding, Decl(a.ts, 304, 54)) +>a : Symbol(a, Decl(a.ts, 304, 65)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a171: Record[] = a170; +>a171 : Symbol(a171, Decl(a.ts, 305, 5)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>a170 : Symbol(a170, Decl(a.ts, 304, 5)) + +const a172: Record[] = a170; +>a172 : Symbol(a172, Decl(a.ts, 306, 5)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>a170 : Symbol(a170, Decl(a.ts, 304, 5)) + +const a173: [number | undefined, string | undefined][] = Iterator.zip<[Iterable, Iterable]>([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); +>a173 : Symbol(a173, Decl(a.ts, 308, 5)) +>Iterator.zip<[Iterable, Iterable]>([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>mode : Symbol(mode, Decl(a.ts, 308, 123)) +>padding : Symbol(padding, Decl(a.ts, 308, 140)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a174: (number | undefined)[][] = Iterator.zip>(a12, { mode: "longest", padding: [0] }).toArray(); +>a174 : Symbol(a174, Decl(a.ts, 309, 5)) +>Iterator.zip>(a12, { mode: "longest", padding: [0] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>a12 : Symbol(a12, Decl(a.ts, 21, 13)) +>mode : Symbol(mode, Decl(a.ts, 309, 76)) +>padding : Symbol(padding, Decl(a.ts, 309, 93)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a175: { a: number | undefined; }[] = Iterator.zipKeyed<{ a: Iterable; }>({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray(); +>a175 : Symbol(a175, Decl(a.ts, 310, 5)) +>a : Symbol(a, Decl(a.ts, 310, 13)) +>Iterator.zipKeyed<{ a: Iterable; }>({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(a.ts, 310, 62)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>a : Symbol(a, Decl(a.ts, 310, 88)) +>mode : Symbol(mode, Decl(a.ts, 310, 100)) +>padding : Symbol(padding, Decl(a.ts, 310, 117)) +>a : Symbol(a, Decl(a.ts, 310, 128)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a176: [number | boolean][] = Iterator.zip<[Iterable], [boolean]>([[1]], { mode: "longest", padding: [false] }).toArray(); +>a176 : Symbol(a176, Decl(a.ts, 311, 5)) +>Iterator.zip<[Iterable], [boolean]>([[1]], { mode: "longest", padding: [false] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>mode : Symbol(mode, Decl(a.ts, 311, 87)) +>padding : Symbol(padding, Decl(a.ts, 311, 104)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +const a177: { a: number | boolean; }[] = Iterator.zipKeyed<{ a: Iterable; }, { a: boolean; }>({ a: [1] }, { mode: "longest", padding: { a: false } }).toArray(); +>a177 : Symbol(a177, Decl(a.ts, 312, 5)) +>a : Symbol(a, Decl(a.ts, 312, 13)) +>Iterator.zipKeyed<{ a: Iterable; }, { a: boolean; }>({ a: [1] }, { mode: "longest", padding: { a: false } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(a.ts, 312, 60)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>a : Symbol(a, Decl(a.ts, 312, 86)) +>a : Symbol(a, Decl(a.ts, 312, 103)) +>mode : Symbol(mode, Decl(a.ts, 312, 115)) +>padding : Symbol(padding, Decl(a.ts, 312, 132)) +>a : Symbol(a, Decl(a.ts, 312, 143)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +Iterator.zipKeyed<{ a: Iterable; }>({ a: [1] }, { mode: "longest", padding: 0 }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(a.ts, 313, 19)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>a : Symbol(a, Decl(a.ts, 313, 45)) +>mode : Symbol(mode, Decl(a.ts, 313, 57)) +>padding : Symbol(padding, Decl(a.ts, 313, 74)) + +Iterator.zipKeyed<{}>({}, { mode: "longest", padding: 0 }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>mode : Symbol(mode, Decl(a.ts, 314, 27)) +>padding : Symbol(padding, Decl(a.ts, 314, 44)) + +Iterator.zipKeyed<{ a: Iterable; }, {}>({ a: [1] }, { mode: "longest", padding: 0 }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(a.ts, 315, 19)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>a : Symbol(a, Decl(a.ts, 315, 49)) +>mode : Symbol(mode, Decl(a.ts, 315, 61)) +>padding : Symbol(padding, Decl(a.ts, 315, 78)) + +=== b.ts === +export function f1>>(a: T) { +>f1 : Symbol(f1, Decl(b.ts, 0, 0)) +>T : Symbol(T, Decl(b.ts, 0, 19)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>a : Symbol(a, Decl(b.ts, 0, 64)) +>T : Symbol(T, Decl(b.ts, 0, 19)) + + return Iterator.zipKeyed(a); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(b.ts, 0, 64)) +} + +export function f2>>(a: T) { +>f2 : Symbol(f2, Decl(b.ts, 2, 1)) +>T : Symbol(T, Decl(b.ts, 4, 19)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>a : Symbol(a, Decl(b.ts, 4, 64)) +>T : Symbol(T, Decl(b.ts, 4, 19)) + + return Iterator.zipKeyed(a, { mode: "longest" }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(b.ts, 4, 64)) +>mode : Symbol(mode, Decl(b.ts, 5, 33)) +} + +export function f3>>(a: T) { +>f3 : Symbol(f3, Decl(b.ts, 6, 1)) +>T : Symbol(T, Decl(b.ts, 8, 19)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>a : Symbol(a, Decl(b.ts, 8, 64)) +>T : Symbol(T, Decl(b.ts, 8, 19)) + + return Iterator.zipKeyed(a, { mode: "longest", padding: {} }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(b.ts, 8, 64)) +>mode : Symbol(mode, Decl(b.ts, 9, 33)) +>padding : Symbol(padding, Decl(b.ts, 9, 50)) +} + +export function f4(a: T) { +>f4 : Symbol(f4, Decl(b.ts, 10, 1)) +>T : Symbol(T, Decl(b.ts, 12, 19)) +>a : Symbol(a, Decl(b.ts, 12, 37)) +>T : Symbol(T, Decl(b.ts, 12, 19)) + + return Iterator.zipKeyed(a); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(b.ts, 12, 37)) +} + +export function f5(a: Iterable, b: U) { +>f5 : Symbol(f5, Decl(b.ts, 14, 1)) +>T : Symbol(T, Decl(b.ts, 16, 19)) +>U : Symbol(U, Decl(b.ts, 16, 21)) +>a : Symbol(a, Decl(b.ts, 16, 25)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>T : Symbol(T, Decl(b.ts, 16, 19)) +>b : Symbol(b, Decl(b.ts, 16, 40)) +>U : Symbol(U, Decl(b.ts, 16, 21)) + + return Iterator.zipKeyed({ a }, { mode: "longest", padding: { a: b } }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(b.ts, 17, 30)) +>mode : Symbol(mode, Decl(b.ts, 17, 37)) +>padding : Symbol(padding, Decl(b.ts, 17, 54)) +>a : Symbol(a, Decl(b.ts, 17, 65)) +>b : Symbol(b, Decl(b.ts, 16, 40)) +} + +export function f6 | Iterator)[]>(a: T) { +>f6 : Symbol(f6, Decl(b.ts, 18, 1)) +>T : Symbol(T, Decl(b.ts, 20, 19)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(b.ts, 20, 81)) +>T : Symbol(T, Decl(b.ts, 20, 19)) + + return Iterator.zip(a); +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>a : Symbol(a, Decl(b.ts, 20, 81)) +} -Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: "invalid" } }); +export function f7(a: Iterable, b: U) { +>f7 : Symbol(f7, Decl(b.ts, 22, 1)) +>T : Symbol(T, Decl(b.ts, 24, 19)) +>U : Symbol(U, Decl(b.ts, 24, 21)) +>a : Symbol(a, Decl(b.ts, 24, 40)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>T : Symbol(T, Decl(b.ts, 24, 19)) +>b : Symbol(b, Decl(b.ts, 24, 55)) +>U : Symbol(U, Decl(b.ts, 24, 21)) + + return Iterator.zipKeyed({ a }, { mode: "longest", padding: b }); +>Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) +>a : Symbol(a, Decl(b.ts, 25, 30)) +>mode : Symbol(mode, Decl(b.ts, 25, 37)) +>padding : Symbol(padding, Decl(b.ts, 25, 54)) +>b : Symbol(b, Decl(b.ts, 24, 55)) +} + +export const a = f1({ a: [1], b: ["a"] }).toArray(); +>a : Symbol(a, Decl(b.ts, 28, 12)) +>f1({ a: [1], b: ["a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>f1 : Symbol(f1, Decl(b.ts, 0, 0)) +>a : Symbol(a, Decl(b.ts, 28, 21)) +>b : Symbol(b, Decl(b.ts, 28, 29)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +export const b = f2({ a: [1], b: ["a"] }).toArray(); +>b : Symbol(b, Decl(b.ts, 29, 12)) +>f2({ a: [1], b: ["a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>f2 : Symbol(f2, Decl(b.ts, 2, 1)) +>a : Symbol(a, Decl(b.ts, 29, 21)) +>b : Symbol(b, Decl(b.ts, 29, 29)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +export const c = f3({ a: [1], b: ["a"] }).toArray(); +>c : Symbol(c, Decl(b.ts, 30, 12)) +>f3({ a: [1], b: ["a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>f3 : Symbol(f3, Decl(b.ts, 6, 1)) +>a : Symbol(a, Decl(b.ts, 30, 21)) +>b : Symbol(b, Decl(b.ts, 30, 29)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +export const d = f4({ a: [1], b: ["a"] }).toArray(); +>d : Symbol(d, Decl(b.ts, 31, 12)) +>f4({ a: [1], b: ["a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>f4 : Symbol(f4, Decl(b.ts, 10, 1)) +>a : Symbol(a, Decl(b.ts, 31, 21)) +>b : Symbol(b, Decl(b.ts, 31, 29)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +export const e = f5([1], false).toArray(); +>e : Symbol(e, Decl(b.ts, 32, 12)) +>f5([1], false).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>f5 : Symbol(f5, Decl(b.ts, 14, 1)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +export const f = f6([[1], ["a"]] as const).toArray(); +>f : Symbol(f, Decl(b.ts, 33, 12)) +>f6([[1], ["a"]] as const).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>f6 : Symbol(f6, Decl(b.ts, 18, 1)) +>const : Symbol(const) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +export const g = f7([1], { a: false }).toArray(); +>g : Symbol(g, Decl(b.ts, 34, 12)) +>f7([1], { a: false }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>f7 : Symbol(f7, Decl(b.ts, 22, 1)) +>a : Symbol(a, Decl(b.ts, 34, 26)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +export const h = Iterator.zip; +>h : Symbol(h, Decl(b.ts, 35, 12)) +>Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) +>Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) +>zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) + +export const i = Iterator.zipKeyed; +>i : Symbol(i, Decl(b.ts, 36, 12)) >Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) >Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) >zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZip.ts, 266, 19)) ->mode : Symbol(mode, Decl(iteratorZip.ts, 266, 31)) ->padding : Symbol(padding, Decl(iteratorZip.ts, 266, 48)) ->a : Symbol(a, Decl(iteratorZip.ts, 266, 59)) + +export const j = h([[1], ["a"]], { mode: "longest", padding: [false, false] }).toArray(); +>j : Symbol(j, Decl(b.ts, 37, 12)) +>h([[1], ["a"]], { mode: "longest", padding: [false, false] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>h : Symbol(h, Decl(b.ts, 35, 12)) +>mode : Symbol(mode, Decl(b.ts, 37, 34)) +>padding : Symbol(padding, Decl(b.ts, 37, 51)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) + +export const k = i({ a: [1], b: [2, 3] }, { mode: "longest", padding: { a: false } }).toArray(); +>k : Symbol(k, Decl(b.ts, 38, 12)) +>i({ a: [1], b: [2, 3] }, { mode: "longest", padding: { a: false } }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) +>i : Symbol(i, Decl(b.ts, 36, 12)) +>a : Symbol(a, Decl(b.ts, 38, 20)) +>b : Symbol(b, Decl(b.ts, 38, 28)) +>mode : Symbol(mode, Decl(b.ts, 38, 43)) +>padding : Symbol(padding, Decl(b.ts, 38, 60)) +>a : Symbol(a, Decl(b.ts, 38, 71)) +>toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).types b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).types index 893dbca54cebd..7bdf390a9c714 100644 --- a/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).types +++ b/tsc/testdata/baselines/reference/compiler/iteratorZip(exactoptionalpropertytypes=true).types @@ -1,6 +1,6 @@ //// [tests/cases/compiler/iteratorZip.ts] //// -=== iteratorZip.ts === +=== a.ts === declare const a1: unique symbol; >a1 : unique symbol @@ -9,9 +9,9 @@ const a2: [number, string][] = Iterator.zip([ >Iterator.zip([ [1, 2], new Set(["a", "b"]),] as const).toArray() : [1 | 2, string][] >Iterator.zip([ [1, 2], new Set(["a", "b"]),] as const).toArray : () => [1 | 2, string][] >Iterator.zip([ [1, 2], new Set(["a", "b"]),] as const) : IteratorObject<[1 | 2, string], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[ [1, 2], new Set(["a", "b"]),] as const : [readonly [1, 2], Set] >[ [1, 2], new Set(["a", "b"]),] : [readonly [1, 2], Set] @@ -44,9 +44,9 @@ const a3: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "shor >Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray() : [1, "a"][] >Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }).toArray : () => [1, "a"][] >Iterator.zip([[1], ["a"]] as const, { mode: "shortest" }) : IteratorObject<[1, "a"], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[[1], ["a"]] as const : [readonly [1], readonly ["a"]] >[[1], ["a"]] : [readonly [1], readonly ["a"]] >[1] : readonly [1] @@ -63,9 +63,9 @@ const a4: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "stri >Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray() : [1, "a"][] >Iterator.zip([[1], ["a"]] as const, { mode: "strict" }).toArray : () => [1, "a"][] >Iterator.zip([[1], ["a"]] as const, { mode: "strict" }) : IteratorObject<[1, "a"], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[[1], ["a"]] as const : [readonly [1], readonly ["a"]] >[[1], ["a"]] : [readonly [1], readonly ["a"]] >[1] : readonly [1] @@ -82,20 +82,20 @@ const a5: [number, string][] = Iterator.zip([[1], ["a"]] as const, { mode: "long >Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray() : [number, string][] >Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }).toArray : () => [number, string][] >Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1, "a"] }) : IteratorObject<[number, string], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[[1], ["a"]] as const : [readonly [1], readonly ["a"]] >[[1], ["a"]] : [readonly [1], readonly ["a"]] >[1] : readonly [1] >1 : 1 >["a"] : readonly ["a"] >"a" : "a" ->{ mode: "longest", padding: [1, "a"] } : { mode: "longest"; padding: [1, "a"]; } +>{ mode: "longest", padding: [1, "a"] } : { mode: "longest"; padding: [number, string]; } >mode : "longest" >"longest" : "longest" ->padding : [1, "a"] ->[1, "a"] : [1, "a"] +>padding : [number, string] +>[1, "a"] : [number, string] >1 : 1 >"a" : "a" >toArray : () => [number, string][] @@ -105,9 +105,9 @@ const a6: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] >Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray() : [1 | undefined, "a" | undefined][] >Iterator.zip([[1], ["a"]] as const, { mode: "longest" }).toArray : () => [1 | undefined, "a" | undefined][] >Iterator.zip([[1], ["a"]] as const, { mode: "longest" }) : IteratorObject<[1 | undefined, "a" | undefined], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[[1], ["a"]] as const : [readonly [1], readonly ["a"]] >[[1], ["a"]] : [readonly [1], readonly ["a"]] >[1] : readonly [1] @@ -124,20 +124,20 @@ const a7: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] >Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray() : [number, "a" | undefined][] >Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }).toArray : () => [number, "a" | undefined][] >Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [1] }) : IteratorObject<[number, "a" | undefined], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[[1], ["a"]] as const : [readonly [1], readonly ["a"]] >[[1], ["a"]] : [readonly [1], readonly ["a"]] >[1] : readonly [1] >1 : 1 >["a"] : readonly ["a"] >"a" : "a" ->{ mode: "longest", padding: [1] } : { mode: "longest"; padding: [1]; } +>{ mode: "longest", padding: [1] } : { mode: "longest"; padding: [number]; } >mode : "longest" >"longest" : "longest" ->padding : [1] ->[1] : [1] +>padding : [number] +>[1] : [number] >1 : 1 >toArray : () => [number, "a" | undefined][] @@ -151,9 +151,9 @@ const a9: [number | undefined, string | undefined][] = Iterator.zip([[1], ["a"]] >Iterator.zip([[1], ["a"]] as const, a8).toArray() : [1 | undefined, "a" | undefined][] >Iterator.zip([[1], ["a"]] as const, a8).toArray : () => [1 | undefined, "a" | undefined][] >Iterator.zip([[1], ["a"]] as const, a8) : IteratorObject<[1 | undefined, "a" | undefined], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[[1], ["a"]] as const : [readonly [1], readonly ["a"]] >[[1], ["a"]] : [readonly [1], readonly ["a"]] >[1] : readonly [1] @@ -168,9 +168,9 @@ const a10: never[] = Iterator.zip([]).toArray(); >Iterator.zip([]).toArray() : never[] >Iterator.zip([]).toArray : () => never[] >Iterator.zip([]) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[] : [] >toArray : () => never[] @@ -179,9 +179,9 @@ const a11: never[] = Iterator.zip([], { mode: "longest" }).toArray(); >Iterator.zip([], { mode: "longest" }).toArray() : never[] >Iterator.zip([], { mode: "longest" }).toArray : () => never[] >Iterator.zip([], { mode: "longest" }) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[] : [] >{ mode: "longest" } : { mode: "longest"; } >mode : "longest" @@ -196,9 +196,9 @@ const a13: number[][] = Iterator.zip(a12).toArray(); >Iterator.zip(a12).toArray() : number[][] >Iterator.zip(a12).toArray : () => number[][] >Iterator.zip(a12) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >a12 : Iterable> >toArray : () => number[][] @@ -207,9 +207,9 @@ const a14: (number | undefined)[][] = Iterator.zip(a12, { mode: "longest" }).toA >Iterator.zip(a12, { mode: "longest" }).toArray() : (number | undefined)[][] >Iterator.zip(a12, { mode: "longest" }).toArray : () => (number | undefined)[][] >Iterator.zip(a12, { mode: "longest" }) : IteratorObject<(number | undefined)[], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >a12 : Iterable> >{ mode: "longest" } : { mode: "longest"; } >mode : "longest" @@ -221,9 +221,9 @@ const a15: (number | undefined)[][] = Iterator.zip(a12, a8).toArray(); >Iterator.zip(a12, a8).toArray() : (number | undefined)[][] >Iterator.zip(a12, a8).toArray : () => (number | undefined)[][] >Iterator.zip(a12, a8) : IteratorObject<(number | undefined)[], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >a12 : Iterable> >a8 : { mode: "shortest"; } | { mode: "longest"; } >toArray : () => (number | undefined)[][] @@ -236,9 +236,9 @@ const a17: (number | undefined)[][] = Iterator.zip(a16, { mode: "longest", paddi >Iterator.zip(a16, { mode: "longest", padding: [] }).toArray() : (number | undefined)[][] >Iterator.zip(a16, { mode: "longest", padding: [] }).toArray : () => (number | undefined)[][] >Iterator.zip(a16, { mode: "longest", padding: [] }) : IteratorObject<(number | undefined)[], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >a16 : Iterable[] >{ mode: "longest", padding: [] } : { mode: "longest"; padding: []; } >mode : "longest" @@ -256,9 +256,9 @@ const a18: { a: number; b: string; [a1]: boolean; }[] = Iterator.zipKeyed({ >Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [a1]: [true, false],} as const).toArray() : ({ a: 1 | 2; b: string; [a1]: boolean; } & {})[] >Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [a1]: [true, false],} as const).toArray : () => ({ a: 1 | 2; b: string; [a1]: boolean; } & {})[] >Iterator.zipKeyed({ a: [1, 2], b: new Set(["a", "b"]), [a1]: [true, false],} as const) : IteratorObject<{ a: 1 | 2; b: string; [a1]: boolean; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: [1, 2], b: new Set(["a", "b"]), [a1]: [true, false],} as const : { readonly a: readonly [1, 2]; readonly b: Set; readonly [a1]: readonly [true, false]; } >{ a: [1, 2], b: new Set(["a", "b"]), [a1]: [true, false],} : { readonly a: readonly [1, 2]; readonly b: Set; readonly [a1]: readonly [true, false]; } @@ -302,9 +302,9 @@ const a19: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}).toArray() : ({ a: number; b: string; } & {})[] >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}).toArray : () => ({ a: number; b: string; } & {})[] >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { a: 1, b: "a" },}) : IteratorObject<{ a: number; b: string; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >a : readonly [1] @@ -313,18 +313,18 @@ const a19: { a: number; b: string; }[] = Iterator.zipKeyed({ a: [1], b: ["a"] } >b : readonly ["a"] >["a"] : readonly ["a"] >"a" : "a" ->{ mode: "longest", padding: { a: 1, b: "a" },} : { mode: "longest"; padding: { a: 1; b: "a"; }; } +>{ mode: "longest", padding: { a: 1, b: "a" },} : { mode: "longest"; padding: { a: number; b: string; }; } mode: "longest", >mode : "longest" >"longest" : "longest" padding: { a: 1, b: "a" }, ->padding : { a: 1; b: "a"; } ->{ a: 1, b: "a" } : { a: 1; b: "a"; } ->a : 1 +>padding : { a: number; b: string; } +>{ a: 1, b: "a" } : { a: number; b: string; } +>a : number >1 : 1 ->b : "a" +>b : string >"a" : "a" }).toArray(); @@ -337,9 +337,9 @@ const a20: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKey >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}).toArray() : ({ a: 1 | undefined; b: "a" | undefined; } & {})[] >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}).toArray : () => ({ a: 1 | undefined; b: "a" | undefined; } & {})[] >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest",}) : IteratorObject<{ a: 1 | undefined; b: "a" | undefined; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >a : readonly [1] @@ -364,9 +364,9 @@ const a21: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKey >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}).toArray() : ({ a: 1 | undefined; b: string; } & {})[] >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}).toArray : () => ({ a: 1 | undefined; b: string; } & {})[] >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, { mode: "longest", padding: { b: "a" },}) : IteratorObject<{ a: 1 | undefined; b: string; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >a : readonly [1] @@ -375,16 +375,16 @@ const a21: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKey >b : readonly ["a"] >["a"] : readonly ["a"] >"a" : "a" ->{ mode: "longest", padding: { b: "a" },} : { mode: "longest"; padding: { b: "a"; }; } +>{ mode: "longest", padding: { b: "a" },} : { mode: "longest"; padding: { b: string; }; } mode: "longest", >mode : "longest" >"longest" : "longest" padding: { b: "a" }, ->padding : { b: "a"; } ->{ b: "a" } : { b: "a"; } ->b : "a" +>padding : { b: string; } +>{ b: "a" } : { b: string; } +>b : string >"a" : "a" }).toArray(); @@ -397,9 +397,9 @@ const a22: { a: number | undefined; b: string | undefined; }[] = Iterator.zipKey >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, a8).toArray() : ({ a: 1 | undefined; b: "a" | undefined; } & {})[] >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, a8).toArray : () => ({ a: 1 | undefined; b: "a" | undefined; } & {})[] >Iterator.zipKeyed({ a: [1], b: ["a"] } as const, a8) : IteratorObject<{ a: 1 | undefined; b: "a" | undefined; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: [1], b: ["a"] } as const : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >{ a: [1], b: ["a"] } : { readonly a: readonly [1]; readonly b: readonly ["a"]; } >a : readonly [1] @@ -429,17 +429,17 @@ const a24: { a: number; b: string; }[] = Iterator.zipKeyed(a23).toArray(); >Iterator.zipKeyed(a23).toArray() : ({ a: number; b: string; } & {})[] >Iterator.zipKeyed(a23).toArray : () => ({ a: number; b: string; } & {})[] >Iterator.zipKeyed(a23) : IteratorObject<{ a: number; b: string; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a23 : I1 >toArray : () => ({ a: number; b: string; } & {})[] Iterator.zip([[1]], { mode: "invalid" }); >Iterator.zip([[1]], { mode: "invalid" }) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[[1]] : [number[]] >[1] : number[] >1 : 1 @@ -447,29 +447,11 @@ Iterator.zip([[1]], { mode: "invalid" }); >mode : "invalid" >"invalid" : "invalid" -Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }); ->Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->[[1], ["a"]] as const : readonly [readonly [1], readonly ["a"]] ->[[1], ["a"]] : readonly [readonly [1], readonly ["a"]] ->[1] : readonly [1] ->1 : 1 ->["a"] : readonly ["a"] ->"a" : "a" ->{ mode: "longest", padding: [true] } : { mode: "longest"; padding: boolean[]; } ->mode : "longest" ->"longest" : "longest" ->padding : boolean[] ->[true] : boolean[] ->true : true - Iterator.zip([[1]], { mode: "shortest", padding: [1] }); >Iterator.zip([[1]], { mode: "shortest", padding: [1] }) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[[1]] : [number[]] >[1] : number[] >1 : 1 @@ -482,16 +464,16 @@ Iterator.zip([[1]], { mode: "shortest", padding: [1] }); Iterator.zip(0); >Iterator.zip(0) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >0 : 0 Iterator.zipKeyed({ a: 0 }); >Iterator.zipKeyed({ a: 0 }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: 0 } : { a: number; } >a : number >0 : 0 @@ -501,9 +483,9 @@ const a25: Record[] = Iterator.zipKeyed({}).toArray(); >Iterator.zipKeyed({}).toArray() : Record[] >Iterator.zipKeyed({}).toArray : () => Record[] >Iterator.zipKeyed({}) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{} : {} >toArray : () => Record[] @@ -512,9 +494,9 @@ const a26: Record[] = Iterator.zipKeyed({}, { mode: "longe >Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray() : Record[] >Iterator.zipKeyed({}, { mode: "longest", padding: {} }).toArray : () => Record[] >Iterator.zipKeyed({}, { mode: "longest", padding: {} }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{} : {} >{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } >mode : "longest" @@ -535,32 +517,32 @@ const a28: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(a27).toArray( >Iterator.zipKeyed(a27).toArray() : (({ a: number; } & {}) | ({ b: string; } & {}))[] >Iterator.zipKeyed(a27).toArray : () => (({ a: number; } & {}) | ({ b: string; } & {}))[] >Iterator.zipKeyed(a27) : IteratorObject<({ a: number; } & {}) | ({ b: string; } & {}), undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a27 : { a: Iterable; } | { b: Iterator; } >toArray : () => (({ a: number; } & {}) | ({ b: string; } & {}))[] Iterator.zip("ab"); >Iterator.zip("ab") : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >"ab" : "ab" Iterator.zip(["ab"]); >Iterator.zip(["ab"]) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >["ab"] : [string] >"ab" : "ab" Iterator.zip(new Set(["ab"])); >Iterator.zip(new Set(["ab"])) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >new Set(["ab"]) : Set >Set : SetConstructor >["ab"] : string[] @@ -568,25 +550,25 @@ Iterator.zip(new Set(["ab"])); Iterator.zipKeyed("ab"); >Iterator.zipKeyed("ab") : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >"ab" : "ab" Iterator.zipKeyed({ a: "ab" }); >Iterator.zipKeyed({ a: "ab" }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: "ab" } : { a: string; } >a : string >"ab" : "ab" Iterator.zip([], { mode: "longest", padding: "ab" }); >Iterator.zip([], { mode: "longest", padding: "ab" }) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[] : [] >{ mode: "longest", padding: "ab" } : { mode: "longest"; padding: string; } >mode : "longest" @@ -596,9 +578,9 @@ Iterator.zip([], { mode: "longest", padding: "ab" }); Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); >Iterator.zip([["a"]], { mode: "longest", padding: "ab" }) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[["a"]] : [string[]] >["a"] : string[] >"a" : "a" @@ -610,9 +592,9 @@ Iterator.zip([["a"]], { mode: "longest", padding: "ab" }); Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }); >Iterator.zipKeyed({}, { mode: "longest", padding: "ab" }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{} : {} >{ mode: "longest", padding: "ab" } : { mode: "longest"; padding: string; } >mode : "longest" @@ -625,9 +607,9 @@ const a29: [string][] = Iterator.zip([new String("ab")]).toArray(); >Iterator.zip([new String("ab")]).toArray() : [string][] >Iterator.zip([new String("ab")]).toArray : () => [string][] >Iterator.zip([new String("ab")]) : IteratorObject<[string], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[new String("ab")] : [String] >new String("ab") : String >String : StringConstructor @@ -640,9 +622,9 @@ const a30: { a: string; }[] = Iterator.zipKeyed({ a: new String("ab") }).toArray >Iterator.zipKeyed({ a: new String("ab") }).toArray() : ({ a: string; } & {})[] >Iterator.zipKeyed({ a: new String("ab") }).toArray : () => ({ a: string; } & {})[] >Iterator.zipKeyed({ a: new String("ab") }) : IteratorObject<{ a: string; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: new String("ab") } : { a: String; } >a : String >new String("ab") : String @@ -655,9 +637,9 @@ const a31: (string | undefined)[][] = Iterator.zip([["a"]], { mode: "longest", p >Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray() : (string | undefined)[][] >Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }).toArray : () => (string | undefined)[][] >Iterator.zip([["a"]], { mode: "longest", padding: new String("ab") }) : IteratorObject<(string | undefined)[], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[["a"]] : string[][] >["a"] : string[] >"a" : "a" @@ -675,9 +657,9 @@ const a32 = Iterator.zipKeyed({ a: [1], b: undefined }).toArray(); >Iterator.zipKeyed({ a: [1], b: undefined }).toArray() : ({ a: number; } & {})[] >Iterator.zipKeyed({ a: [1], b: undefined }).toArray : () => ({ a: number; } & {})[] >Iterator.zipKeyed({ a: [1], b: undefined }) : IteratorObject<{ a: number; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: [1], b: undefined } : { a: number[]; b: undefined; } >a : number[] >[1] : number[] @@ -703,9 +685,9 @@ const a34: never[] = Iterator.zipKeyed({ a: undefined }).toArray(); >Iterator.zipKeyed({ a: undefined }).toArray() : never[] >Iterator.zipKeyed({ a: undefined }).toArray : () => never[] >Iterator.zipKeyed({ a: undefined }) : IteratorObject ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: undefined } : { a: undefined; } >a : undefined >undefined : undefined @@ -716,9 +698,9 @@ const a35: never[] = Iterator.zipKeyed({ a: undefined }, { mode: "longest", padd >Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray() : never[] >Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }).toArray : () => never[] >Iterator.zipKeyed({ a: undefined }, { mode: "longest", padding: {} }) : IteratorObject ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: undefined } : { a: undefined; } >a : undefined >undefined : undefined @@ -750,9 +732,9 @@ const a37 = Iterator.zipKeyed(a36).toArray(); >Iterator.zipKeyed(a36).toArray() : ({ a: number; } & { b?: string; c?: boolean; })[] >Iterator.zipKeyed(a36).toArray : () => ({ a: number; } & { b?: string; c?: boolean; })[] >Iterator.zipKeyed(a36) : IteratorObject<{ a: number; } & { b?: string; c?: boolean; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a36 : I2 >toArray : () => ({ a: number; } & { b?: string; c?: boolean; })[] @@ -811,9 +793,9 @@ const a40: { a: number | undefined; b?: string | undefined; c?: boolean | undefi >Iterator.zipKeyed(a36, { mode: "longest" }).toArray() : ({ a: number | undefined; } & { b?: string | undefined; c?: boolean | undefined; })[] >Iterator.zipKeyed(a36, { mode: "longest" }).toArray : () => ({ a: number | undefined; } & { b?: string | undefined; c?: boolean | undefined; })[] >Iterator.zipKeyed(a36, { mode: "longest" }) : IteratorObject<{ a: number | undefined; } & { b?: string | undefined; c?: boolean | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a36 : I2 >{ mode: "longest" } : { mode: "longest"; } >mode : "longest" @@ -832,9 +814,9 @@ const a42: ({ a: number; } | { b: string; })[] = Iterator.zipKeyed(a41).toArray( >Iterator.zipKeyed(a41).toArray() : (({ a: number; } & {}) | ({ b: string; } & {}))[] >Iterator.zipKeyed(a41).toArray : () => (({ a: number; } & {}) | ({ b: string; } & {}))[] >Iterator.zipKeyed(a41) : IteratorObject<({ a: number; } & {}) | ({ b: string; } & {}), undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a41 : { a: Iterable; } | { b: Iterator; } >toArray : () => (({ a: number; } & {}) | ({ b: string; } & {}))[] @@ -845,16 +827,16 @@ declare const a43: { a: Iterable; } | { b: number; }; Iterator.zipKeyed(a43); >Iterator.zipKeyed(a43) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a43 : { a: Iterable; } | { b: number; } Iterator.zipKeyed(a43, { mode: "longest" }); >Iterator.zipKeyed(a43, { mode: "longest" }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a43 : { a: Iterable; } | { b: number; } >{ mode: "longest" } : { mode: "longest"; } >mode : "longest" @@ -862,9 +844,9 @@ Iterator.zipKeyed(a43, { mode: "longest" }); Iterator.zipKeyed(a43, { mode: "longest", padding: {} }); >Iterator.zipKeyed(a43, { mode: "longest", padding: {} }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a43 : { a: Iterable; } | { b: number; } >{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } >mode : "longest" @@ -879,9 +861,9 @@ declare const a44: { a?: Iterable; } | { b: string; }; Iterator.zipKeyed(a44); >Iterator.zipKeyed(a44) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a44 : { a?: Iterable; } | { b: string; } declare const a45: { a: Iterable; } | { b: undefined; }; @@ -895,9 +877,9 @@ const a46: { a: number; }[] = Iterator.zipKeyed(a45).toArray(); >Iterator.zipKeyed(a45).toArray() : ({ a: number; } & {})[] >Iterator.zipKeyed(a45).toArray : () => ({ a: number; } & {})[] >Iterator.zipKeyed(a45) : IteratorObject<{ a: number; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a45 : { a: Iterable; } | { b: undefined; } >toArray : () => ({ a: number; } & {})[] @@ -918,17 +900,17 @@ const a49: { a: number; [a47]?: string; }[] = Iterator.zipKeyed(a48).toArray(); >Iterator.zipKeyed(a48).toArray() : ({ a: number; } & { [a47]?: string; })[] >Iterator.zipKeyed(a48).toArray : () => ({ a: number; } & { [a47]?: string; })[] >Iterator.zipKeyed(a48) : IteratorObject<{ a: number; } & { [a47]?: string; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a48 : { a: Iterable; [a47]?: Iterable; } >toArray : () => ({ a: number; } & { [a47]?: string; })[] Iterator.zipKeyed({ a: [1], b: null }); >Iterator.zipKeyed({ a: [1], b: null }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: [1], b: null } : { a: number[]; b: null; } >a : number[] >[1] : number[] @@ -937,9 +919,9 @@ Iterator.zipKeyed({ a: [1], b: null }); Iterator.zipKeyed({ a: [1], b: false }); >Iterator.zipKeyed({ a: [1], b: false }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: [1], b: false } : { a: number[]; b: false; } >a : number[] >[1] : number[] @@ -949,9 +931,9 @@ Iterator.zipKeyed({ a: [1], b: false }); Iterator.zip([undefined]); >Iterator.zip([undefined]) : IteratorObject ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[undefined] : [undefined] >undefined : undefined @@ -964,9 +946,9 @@ const a51: never[] = Iterator.zipKeyed(a50).toArray(); >Iterator.zipKeyed(a50).toArray() : never[] >Iterator.zipKeyed(a50).toArray : () => never[] >Iterator.zipKeyed(a50) : IteratorObject ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a50 : { a?: undefined; } >toArray : () => never[] @@ -976,9 +958,9 @@ const a52: { a: number; }[] = Iterator.zipKeyed({ a: [1], b: undefined }, { mode >Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray() : ({ a: number; } & {})[] >Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }).toArray : () => ({ a: number; } & {})[] >Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest", padding: { a: 0 } }) : IteratorObject<{ a: number; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: [1], b: undefined } : { a: number[]; b: undefined; } >a : number[] >[1] : number[] @@ -1000,9 +982,9 @@ const a53: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: undefin >Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray() : ({ a: number | undefined; } & {})[] >Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }).toArray : () => ({ a: number | undefined; } & {})[] >Iterator.zipKeyed({ a: [1], b: undefined }, { mode: "longest" }) : IteratorObject<{ a: number | undefined; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: [1], b: undefined } : { a: number[]; b: undefined; } >a : number[] >[1] : number[] @@ -1024,9 +1006,9 @@ function f1(a: Iterable) { >Iterator.zipKeyed({ a }).toArray() : ({ a: T; } & {})[] >Iterator.zipKeyed({ a }).toArray : () => ({ a: T; } & {})[] >Iterator.zipKeyed({ a }) : IteratorObject<{ a: T; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a } : { a: Iterable; } >a : Iterable >toArray : () => ({ a: T; } & {})[] @@ -1036,9 +1018,9 @@ function f1(a: Iterable) { >Iterator.zip([a]).toArray() : [T][] >Iterator.zip([a]).toArray : () => [T][] >Iterator.zip([a]) : IteratorObject<[T], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T_1, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T_1, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T_1, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T_1 extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T_1 extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T_1, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T_1, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T_1, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T_1 extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T_1 extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T_1 extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T_1, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T_1, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T_1, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T_1 extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T_1 extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T_1, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T_1, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T_1, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T_1 extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T_1 extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T_1 extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[a] : [Iterable] >a : Iterable >toArray : () => [T][] @@ -1063,9 +1045,9 @@ const a55 = Iterator.zip(a54, { mode: "longest", padding: [0] }).toArray(); >Iterator.zip(a54, { mode: "longest", padding: [0] }).toArray() : [number, ...(number | undefined)[]][] >Iterator.zip(a54, { mode: "longest", padding: [0] }).toArray : () => [number, ...(number | undefined)[]][] >Iterator.zip(a54, { mode: "longest", padding: [0] }) : IteratorObject<[number, ...(number | undefined)[]], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >a54 : [Iterable, ...Iterable[]] >{ mode: "longest", padding: [0] } : { mode: "longest"; padding: [number]; } >mode : "longest" @@ -1099,9 +1081,9 @@ const a59 = Iterator.zipKeyed(a58, { mode: "longest", padding: {} }).toArray(); >Iterator.zipKeyed(a58, { mode: "longest", padding: {} }).toArray() : ({ [x: string]: number | undefined; } & {})[] >Iterator.zipKeyed(a58, { mode: "longest", padding: {} }).toArray : () => ({ [x: string]: number | undefined; } & {})[] >Iterator.zipKeyed(a58, { mode: "longest", padding: {} }) : IteratorObject<{ [x: string]: number | undefined; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a58 : Record> >{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } >mode : "longest" @@ -1126,9 +1108,9 @@ const a63 = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: >Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a62 }).toArray() : ({ a: number | undefined; b: number | undefined; } & {})[] >Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a62 }).toArray : () => ({ a: number | undefined; b: number | undefined; } & {})[] >Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a62 }) : IteratorObject<{ a: number | undefined; b: number | undefined; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: [1], b: [2, 3] } : { a: number[]; b: number[]; } >a : number[] >[1] : number[] @@ -1161,9 +1143,9 @@ const a66 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).to >Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray() : [number, string][] >Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray : () => [number, string][] >Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0, ""] }) : IteratorObject<[number, string], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[[1], ["a"]] : [number[], string[]] >[1] : number[] >1 : 1 @@ -1187,9 +1169,9 @@ const a68 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: >Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray() : ({ a: number; b: string; } & {})[] >Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }).toArray : () => ({ a: number; b: string; } & {})[] >Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0, b: "" } }) : IteratorObject<{ a: number; b: string; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } >a : number[] >[1] : number[] @@ -1219,9 +1201,9 @@ const a70 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArra >Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray() : [number, string | undefined][] >Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }).toArray : () => [number, string | undefined][] >Iterator.zip([[1], ["a"]], { mode: "longest", padding: [0] }) : IteratorObject<[number, string | undefined], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[[1], ["a"]] : [number[], string[]] >[1] : number[] >1 : 1 @@ -1248,9 +1230,9 @@ const a73 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: >Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray() : ({ a: number; b: string | undefined; } & {})[] >Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }).toArray : () => ({ a: number; b: string | undefined; } & {})[] >Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: { a: 0 } }) : IteratorObject<{ a: number; b: string | undefined; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } >a : number[] >[1] : number[] @@ -1287,9 +1269,9 @@ const a77: [number, string][] = Iterator.zip([[1], ["a"]], { mode: "longest", pa >Iterator.zip([[1], ["a"]], { mode: "longest", padding: a76 }).toArray() : [number, string][] >Iterator.zip([[1], ["a"]], { mode: "longest", padding: a76 }).toArray : () => [number, string][] >Iterator.zip([[1], ["a"]], { mode: "longest", padding: a76 }) : IteratorObject<[number, string], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[[1], ["a"]] : [number[], string[]] >[1] : number[] >1 : 1 @@ -1310,9 +1292,9 @@ const a79 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a78 }).toArra >Iterator.zip([[1], ["a"]], { mode: "longest", padding: a78 }).toArray() : [number, string | undefined][] >Iterator.zip([[1], ["a"]], { mode: "longest", padding: a78 }).toArray : () => [number, string | undefined][] >Iterator.zip([[1], ["a"]], { mode: "longest", padding: a78 }) : IteratorObject<[number, string | undefined], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[[1], ["a"]] : [number[], string[]] >[1] : number[] >1 : 1 @@ -1337,9 +1319,9 @@ const a82 = Iterator.zip(a81, { mode: "longest", padding: [0] }).toArray(); >Iterator.zip(a81, { mode: "longest", padding: [0] }).toArray() : ([number] | [number, number | undefined])[] >Iterator.zip(a81, { mode: "longest", padding: [0] }).toArray : () => ([number] | [number, number | undefined])[] >Iterator.zip(a81, { mode: "longest", padding: [0] }) : IteratorObject<[number] | [number, number | undefined], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >a81 : [Iterable] | [Iterable, Iterable] >{ mode: "longest", padding: [0] } : { mode: "longest"; padding: [number]; } >mode : "longest" @@ -1363,9 +1345,9 @@ const a85 = Iterator.zipKeyed(a84, { mode: "longest", padding: { a: 0 } }).toArr >Iterator.zipKeyed(a84, { mode: "longest", padding: { a: 0 } }).toArray() : (({ a: number; } & {}) | ({ b: string | undefined; } & {}))[] >Iterator.zipKeyed(a84, { mode: "longest", padding: { a: 0 } }).toArray : () => (({ a: number; } & {}) | ({ b: string | undefined; } & {}))[] >Iterator.zipKeyed(a84, { mode: "longest", padding: { a: 0 } }) : IteratorObject<({ a: number; } & {}) | ({ b: string | undefined; } & {}), undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a84 : { a: Iterable; } | { b: Iterable; } >{ mode: "longest", padding: { a: 0 } } : { mode: "longest"; padding: { a: number; }; } >mode : "longest" @@ -1392,9 +1374,9 @@ const a88 = Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: >Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: a87 }).toArray() : ({ a: number | undefined; b: string | undefined; } & {})[] >Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: a87 }).toArray : () => ({ a: number | undefined; b: string | undefined; } & {})[] >Iterator.zipKeyed({ a: [1], b: ["a"] }, { mode: "longest", padding: a87 }) : IteratorObject<{ a: number | undefined; b: string | undefined; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } >a : number[] >[1] : number[] @@ -1420,9 +1402,9 @@ const a90 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { >Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray() : ({ a: number | undefined; b: number; } & {})[] >Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }).toArray : () => ({ a: number | undefined; b: number; } & {})[] >Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: { a: undefined, b: 0 } }) : IteratorObject<{ a: number | undefined; b: number; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: [1], b: [2] } : { a: number[]; b: number[]; } >a : number[] >[1] : number[] @@ -1455,9 +1437,9 @@ const a93 = Iterator.zipKeyed(a92, { mode: "longest", padding: {} }).toArray(); >Iterator.zipKeyed(a92, { mode: "longest", padding: {} }).toArray() : ({ [x: `a${string}`]: number | undefined; } & {})[] >Iterator.zipKeyed(a92, { mode: "longest", padding: {} }).toArray : () => ({ [x: `a${string}`]: number | undefined; } & {})[] >Iterator.zipKeyed(a92, { mode: "longest", padding: {} }) : IteratorObject<{ [x: `a${string}`]: number | undefined; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a92 : { [x: `a${string}`]: Iterable; } >{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } >mode : "longest" @@ -1480,9 +1462,9 @@ const a96: { [a95]: number; }[] = Iterator.zipKeyed({ [a95]: [1] }, { mode: "lon >Iterator.zipKeyed({ [a95]: [1] }, { mode: "longest", padding: { [a95]: 0 } }).toArray() : ({ [a95]: number; } & {})[] >Iterator.zipKeyed({ [a95]: [1] }, { mode: "longest", padding: { [a95]: 0 } }).toArray : () => ({ [a95]: number; } & {})[] >Iterator.zipKeyed({ [a95]: [1] }, { mode: "longest", padding: { [a95]: 0 } }) : IteratorObject<{ [a95]: number; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ [a95]: [1] } : { [a95]: number[]; } >[a95] : number[] >a95 : unique symbol @@ -1507,9 +1489,9 @@ const a98 = Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: a9 >Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: a97 }).toArray() : ({ a: number; b: number | undefined; } & {})[] >Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: a97 }).toArray : () => ({ a: number; b: number | undefined; } & {})[] >Iterator.zipKeyed({ a: [1], b: [2] }, { mode: "longest", padding: a97 }) : IteratorObject<{ a: number; b: number | undefined; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: [1], b: [2] } : { a: number[]; b: number[]; } >a : number[] >[1] : number[] @@ -1544,9 +1526,9 @@ const a102 = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a101 }).toAr >Iterator.zip([[1], ["a"]], { mode: "longest", padding: a101 }).toArray() : [number, string | undefined][] >Iterator.zip([[1], ["a"]], { mode: "longest", padding: a101 }).toArray : () => [number, string | undefined][] >Iterator.zip([[1], ["a"]], { mode: "longest", padding: a101 }) : IteratorObject<[number, string | undefined], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[[1], ["a"]] : [number[], string[]] >[1] : number[] >1 : 1 @@ -1572,9 +1554,9 @@ const a105: [number | undefined, number][] = Iterator.zip([[1], [2]], { mode: "l >Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray() : [number | undefined, number][] >Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }).toArray : () => [number | undefined, number][] >Iterator.zip([[1], [2]], { mode: "longest", padding: [undefined, 0] }) : IteratorObject<[number | undefined, number], undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >[[1], [2]] : [number[], number[]] >[1] : number[] >1 : 1 @@ -1631,9 +1613,9 @@ const a108 = Iterator.zipKeyed(a107).toArray(); >Iterator.zipKeyed(a107).toArray() : Record[] >Iterator.zipKeyed(a107).toArray : () => Record[] >Iterator.zipKeyed(a107) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a107 : C1 >toArray : () => Record[] @@ -1642,9 +1624,9 @@ const a109 = Iterator.zipKeyed(a107, { mode: "strict" }).toArray(); >Iterator.zipKeyed(a107, { mode: "strict" }).toArray() : Record[] >Iterator.zipKeyed(a107, { mode: "strict" }).toArray : () => Record[] >Iterator.zipKeyed(a107, { mode: "strict" }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a107 : C1 >{ mode: "strict" } : { mode: "strict"; } >mode : "strict" @@ -1656,9 +1638,9 @@ const a110 = Iterator.zipKeyed(a107, { mode: "longest" }).toArray(); >Iterator.zipKeyed(a107, { mode: "longest" }).toArray() : Record[] >Iterator.zipKeyed(a107, { mode: "longest" }).toArray : () => Record[] >Iterator.zipKeyed(a107, { mode: "longest" }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a107 : C1 >{ mode: "longest" } : { mode: "longest"; } >mode : "longest" @@ -1670,9 +1652,9 @@ const a111 = Iterator.zipKeyed(a107, { mode: "longest", padding: { a: 0 } }).toA >Iterator.zipKeyed(a107, { mode: "longest", padding: { a: 0 } }).toArray() : Record[] >Iterator.zipKeyed(a107, { mode: "longest", padding: { a: 0 } }).toArray : () => Record[] >Iterator.zipKeyed(a107, { mode: "longest", padding: { a: 0 } }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a107 : C1 >{ mode: "longest", padding: { a: 0 } } : { mode: "longest"; padding: { a: number; }; } >mode : "longest" @@ -1709,9 +1691,9 @@ const a113 = Iterator.zipKeyed(a112).toArray(); >Iterator.zipKeyed(a112).toArray() : Record[] >Iterator.zipKeyed(a112).toArray : () => Record[] >Iterator.zipKeyed(a112) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a112 : { a: number[]; b: string; } >toArray : () => Record[] @@ -1720,9 +1702,9 @@ const a114 = Iterator.zipKeyed(a112, { mode: "longest", padding: { a: 0 } }).toA >Iterator.zipKeyed(a112, { mode: "longest", padding: { a: 0 } }).toArray() : Record[] >Iterator.zipKeyed(a112, { mode: "longest", padding: { a: 0 } }).toArray : () => Record[] >Iterator.zipKeyed(a112, { mode: "longest", padding: { a: 0 } }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a112 : { a: number[]; b: string; } >{ mode: "longest", padding: { a: 0 } } : { mode: "longest"; padding: { a: number; }; } >mode : "longest" @@ -1748,9 +1730,9 @@ const a116 = Iterator.zipKeyed(a115).toArray(); >Iterator.zipKeyed(a115).toArray() : Record[] >Iterator.zipKeyed(a115).toArray : () => Record[] >Iterator.zipKeyed(a115) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a115 : { a: number[]; b: string; } >toArray : () => Record[] @@ -1759,9 +1741,9 @@ const a117 = Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray(); >Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray() : Record[] >Iterator.zipKeyed([[1, 2], ["a", "b"]]).toArray : () => Record[] >Iterator.zipKeyed([[1, 2], ["a", "b"]]) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >[[1, 2], ["a", "b"]] : (string[] | number[])[] >[1, 2] : number[] >1 : 1 @@ -1798,9 +1780,9 @@ const a121: { a: number; [a120]: string; }[] = Iterator.zipKeyed({ a: [1], [a120 >Iterator.zipKeyed({ a: [1], [a120]: ["a"] }).toArray() : ({ a: number; [a120]: string; } & {})[] >Iterator.zipKeyed({ a: [1], [a120]: ["a"] }).toArray : () => ({ a: number; [a120]: string; } & {})[] >Iterator.zipKeyed({ a: [1], [a120]: ["a"] }) : IteratorObject<{ a: number; [a120]: string; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: [1], [a120]: ["a"] } : { a: number[]; [a120]: string[]; } >a : number[] >[1] : number[] @@ -1817,9 +1799,9 @@ const a122: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1] }, { mode: >Iterator.zipKeyed({ a: [1] }, { mode: "longest" }).toArray() : ({ a: number | undefined; } & {})[] >Iterator.zipKeyed({ a: [1] }, { mode: "longest" }).toArray : () => ({ a: number | undefined; } & {})[] >Iterator.zipKeyed({ a: [1] }, { mode: "longest" }) : IteratorObject<{ a: number | undefined; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: [1] } : { a: number[]; } >a : number[] >[1] : number[] @@ -1835,9 +1817,9 @@ const a123: { a: number; }[] = Iterator.zipKeyed({ a: [1] }, { mode: "longest", >Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray() : ({ a: number; } & {})[] >Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray : () => ({ a: number; } & {})[] >Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: 0 } }) : IteratorObject<{ a: number; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >{ a: [1] } : { a: number[]; } >a : number[] >[1] : number[] @@ -1859,9 +1841,9 @@ const a125 = Iterator.zipKeyed(a124).toArray(); >Iterator.zipKeyed(a124).toArray() : Record[] >Iterator.zipKeyed(a124).toArray : () => Record[] >Iterator.zipKeyed(a124) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a124 : object >toArray : () => Record[] @@ -1870,9 +1852,9 @@ const a126 = Iterator.zipKeyed(a124, { mode: "strict" }).toArray(); >Iterator.zipKeyed(a124, { mode: "strict" }).toArray() : Record[] >Iterator.zipKeyed(a124, { mode: "strict" }).toArray : () => Record[] >Iterator.zipKeyed(a124, { mode: "strict" }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a124 : object >{ mode: "strict" } : { mode: "strict"; } >mode : "strict" @@ -1884,9 +1866,9 @@ const a127 = Iterator.zipKeyed(a124, { mode: "longest" }).toArray(); >Iterator.zipKeyed(a124, { mode: "longest" }).toArray() : Record[] >Iterator.zipKeyed(a124, { mode: "longest" }).toArray : () => Record[] >Iterator.zipKeyed(a124, { mode: "longest" }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a124 : object >{ mode: "longest" } : { mode: "longest"; } >mode : "longest" @@ -1898,9 +1880,9 @@ const a128 = Iterator.zipKeyed(a124, { mode: "longest", padding: { a: 0 } }).toA >Iterator.zipKeyed(a124, { mode: "longest", padding: { a: 0 } }).toArray() : Record[] >Iterator.zipKeyed(a124, { mode: "longest", padding: { a: 0 } }).toArray : () => Record[] >Iterator.zipKeyed(a124, { mode: "longest", padding: { a: 0 } }) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a124 : object >{ mode: "longest", padding: { a: 0 } } : { mode: "longest"; padding: { a: number; }; } >mode : "longest" @@ -1955,9 +1937,9 @@ const a135 = Iterator.zipKeyed(a134).toArray(); >Iterator.zipKeyed(a134).toArray() : Record[] >Iterator.zipKeyed(a134).toArray : () => Record[] >Iterator.zipKeyed(a134) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a134 : {} >toArray : () => Record[] @@ -1975,22 +1957,22 @@ const a137: never[] = a135; Iterator.zipKeyed(0); >Iterator.zipKeyed(0) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >0 : 0 Iterator.zipKeyed(null); >Iterator.zipKeyed(null) : IteratorObject, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } Iterator.zipKeyed(a107, { mode: "invalid" }); >Iterator.zipKeyed(a107, { mode: "invalid" }) : IteratorObject<{ a: number; b: never; f: never; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a107 : C1 >{ mode: "invalid" } : { mode: "invalid"; } >mode : "invalid" @@ -1998,9 +1980,9 @@ Iterator.zipKeyed(a107, { mode: "invalid" }); Iterator.zipKeyed(a107, { mode: "shortest", padding: {} }); >Iterator.zipKeyed(a107, { mode: "shortest", padding: {} }) : IteratorObject<{ a: number; b: never; f: never; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a107 : C1 >{ mode: "shortest", padding: {} } : { mode: "shortest"; padding: {}; } >mode : "shortest" @@ -2010,9 +1992,9 @@ Iterator.zipKeyed(a107, { mode: "shortest", padding: {} }); Iterator.zipKeyed(a107, { mode: "longest", padding: 0 }); >Iterator.zipKeyed(a107, { mode: "longest", padding: 0 }) : IteratorObject<{ a: number; b: never; f: never; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } >a107 : C1 >{ mode: "longest", padding: 0 } : { mode: "longest"; padding: number; } >mode : "longest" @@ -2020,20 +2002,872 @@ Iterator.zipKeyed(a107, { mode: "longest", padding: 0 }); >padding : number >0 : 0 -Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: "invalid" } }); ->Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: "invalid" } }) : IteratorObject<{ a: number; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } +const a138: [number | boolean, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }).toArray(); +>a138 : [number | boolean, string | undefined][] +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }).toArray() : [1 | boolean, "a" | undefined][] +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }).toArray : () => [1 | boolean, "a" | undefined][] +>Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }) : IteratorObject<[1 | boolean, "a" | undefined], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } >Iterator : IteratorConstructor ->zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->{ a: [1] } : { a: number[]; } +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] as const : [readonly [1], readonly ["a"]] +>[[1], ["a"]] : [readonly [1], readonly ["a"]] +>[1] : readonly [1] +>1 : 1 +>["a"] : readonly ["a"] +>"a" : "a" +>{ mode: "longest", padding: [true] } : { mode: "longest"; padding: [true]; } +>mode : "longest" +>"longest" : "longest" +>padding : [true] +>[true] : [true] +>true : true +>toArray : () => [1 | boolean, "a" | undefined][] + +const a139: { a: number | string; b: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: { a: "a" } }).toArray(); +>a139 : { a: number | string; b: number | undefined; }[] +>a : string | number +>b : number | undefined +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: { a: "a" } }).toArray() : ({ a: string | number; b: number | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: { a: "a" } }).toArray : () => ({ a: string | number; b: number | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: { a: "a" } }) : IteratorObject<{ a: string | number; b: number | undefined; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>{ a: [1], b: [2, 3] } : { a: number[]; b: number[]; } >a : number[] >[1] : number[] >1 : 1 ->{ mode: "longest", padding: { a: "invalid" } } : { mode: "longest"; padding: { a: string; }; } +>b : number[] +>[2, 3] : number[] +>2 : 2 +>3 : 3 +>{ mode: "longest", padding: { a: "a" } } : { mode: "longest"; padding: { a: string; }; } >mode : "longest" >"longest" : "longest" >padding : { a: string; } ->{ a: "invalid" } : { a: string; } +>{ a: "a" } : { a: string; } >a : string ->"invalid" : "invalid" +>"a" : "a" +>toArray : () => ({ a: string | number; b: number | undefined; } & {})[] + +declare const a140: boolean[]; +>a140 : boolean[] + +const a141: [number | boolean | undefined, string | boolean | undefined][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a140 }).toArray(); +>a141 : [number | boolean | undefined, string | boolean | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: a140 }).toArray() : [number | boolean | undefined, string | boolean | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: a140 }).toArray : () => [number | boolean | undefined, string | boolean | undefined][] +>Iterator.zip([[1], ["a"]], { mode: "longest", padding: a140 }) : IteratorObject<[number | boolean | undefined, string | boolean | undefined], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] : [number[], string[]] +>[1] : number[] +>1 : 1 +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: a140 } : { mode: "longest"; padding: boolean[]; } +>mode : "longest" +>"longest" : "longest" +>padding : boolean[] +>a140 : boolean[] +>toArray : () => [number | boolean | undefined, string | boolean | undefined][] + +const a142 = Iterator.zip(a12, { mode: "longest", padding: new Set([false]) }).toArray(); +>a142 : (number | boolean | undefined)[][] +>Iterator.zip(a12, { mode: "longest", padding: new Set([false]) }).toArray() : (number | boolean | undefined)[][] +>Iterator.zip(a12, { mode: "longest", padding: new Set([false]) }).toArray : () => (number | boolean | undefined)[][] +>Iterator.zip(a12, { mode: "longest", padding: new Set([false]) }) : IteratorObject<(number | boolean | undefined)[], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>a12 : Iterable> +>{ mode: "longest", padding: new Set([false]) } : { mode: "longest"; padding: Set; } +>mode : "longest" +>"longest" : "longest" +>padding : Set +>new Set([false]) : Set +>Set : SetConstructor +>[false] : false[] +>false : false +>toArray : () => (number | boolean | undefined)[][] + +const a143: (number | boolean | undefined)[][] = a142; +>a143 : (number | boolean | undefined)[][] +>a142 : (number | boolean | undefined)[][] + +const a144: (number | undefined)[][] = a142; +>a144 : (number | undefined)[][] +>a142 : (number | boolean | undefined)[][] + +const a145: (number | boolean | undefined)[][] = Iterator.zip([[1], [2, 3]], { mode: "longest", padding: new Set([false]) }).toArray(); +>a145 : (number | boolean | undefined)[][] +>Iterator.zip([[1], [2, 3]], { mode: "longest", padding: new Set([false]) }).toArray() : (number | boolean | undefined)[][] +>Iterator.zip([[1], [2, 3]], { mode: "longest", padding: new Set([false]) }).toArray : () => (number | boolean | undefined)[][] +>Iterator.zip([[1], [2, 3]], { mode: "longest", padding: new Set([false]) }) : IteratorObject<(number | boolean | undefined)[], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], [2, 3]] : number[][] +>[1] : number[] +>1 : 1 +>[2, 3] : number[] +>2 : 2 +>3 : 3 +>{ mode: "longest", padding: new Set([false]) } : { mode: "longest"; padding: Set; } +>mode : "longest" +>"longest" : "longest" +>padding : Set +>new Set([false]) : Set +>Set : SetConstructor +>[false] : false[] +>false : false +>toArray : () => (number | boolean | undefined)[][] + +declare const a146: { a: boolean; } | { b: string; }; +>a146 : { a: boolean; } | { b: string; } +>a : boolean +>b : string + +const a147 = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a146 }).toArray(); +>a147 : ({ a: number | boolean | undefined; b: string | number | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a146 }).toArray() : ({ a: number | boolean | undefined; b: string | number | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a146 }).toArray : () => ({ a: number | boolean | undefined; b: string | number | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a146 }) : IteratorObject<{ a: number | boolean | undefined; b: string | number | undefined; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>{ a: [1], b: [2, 3] } : { a: number[]; b: number[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : number[] +>[2, 3] : number[] +>2 : 2 +>3 : 3 +>{ mode: "longest", padding: a146 } : { mode: "longest"; padding: { a: boolean; } | { b: string; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: boolean; } | { b: string; } +>a146 : { a: boolean; } | { b: string; } +>toArray : () => ({ a: number | boolean | undefined; b: string | number | undefined; } & {})[] + +const a148: { a: number | boolean | undefined; b: number | string | undefined; }[] = a147; +>a148 : { a: number | boolean | undefined; b: number | string | undefined; }[] +>a : number | boolean | undefined +>b : string | number | undefined +>a147 : ({ a: number | boolean | undefined; b: string | number | undefined; } & {})[] + +const a149: { a: number | undefined; b: number | undefined; }[] = a147; +>a149 : { a: number | undefined; b: number | undefined; }[] +>a : number | undefined +>b : number | undefined +>a147 : ({ a: number | boolean | undefined; b: string | number | undefined; } & {})[] + +declare const a150: [boolean] | [string, string]; +>a150 : [boolean] | [string, string] + +const a151: [number | boolean | string, number | string | undefined][] = Iterator.zip([[1], [2, 3]], { mode: "longest", padding: a150 }).toArray(); +>a151 : [string | number | boolean, string | number | undefined][] +>Iterator.zip([[1], [2, 3]], { mode: "longest", padding: a150 }).toArray() : [string | number | boolean, string | number | undefined][] +>Iterator.zip([[1], [2, 3]], { mode: "longest", padding: a150 }).toArray : () => [string | number | boolean, string | number | undefined][] +>Iterator.zip([[1], [2, 3]], { mode: "longest", padding: a150 }) : IteratorObject<[string | number | boolean, string | number | undefined], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], [2, 3]] : [number[], number[]] +>[1] : number[] +>1 : 1 +>[2, 3] : number[] +>2 : 2 +>3 : 3 +>{ mode: "longest", padding: a150 } : { mode: "longest"; padding: [boolean] | [string, string]; } +>mode : "longest" +>"longest" : "longest" +>padding : [boolean] | [string, string] +>a150 : [boolean] | [string, string] +>toArray : () => [string | number | boolean, string | number | undefined][] + +declare const a152: { mode: "longest"; padding?: { a: boolean; }; }; +>a152 : { mode: "longest"; padding?: { a: boolean; }; } +>mode : "longest" +>padding : { a: boolean; } | undefined +>a : boolean + +const a153 = Iterator.zipKeyed({ a: [1] }, a152).toArray(); +>a153 : ({ a: number | boolean | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1] }, a152).toArray() : ({ a: number | boolean | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1] }, a152).toArray : () => ({ a: number | boolean | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1] }, a152) : IteratorObject<{ a: number | boolean | undefined; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>{ a: [1] } : { a: number[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>a152 : { mode: "longest"; padding?: { a: boolean; }; } +>toArray : () => ({ a: number | boolean | undefined; } & {})[] + +const a154: { a: number | boolean | undefined; }[] = a153; +>a154 : { a: number | boolean | undefined; }[] +>a : number | boolean | undefined +>a153 : ({ a: number | boolean | undefined; } & {})[] + +const a155: { a: number | boolean; }[] = a153; +>a155 : { a: number | boolean; }[] +>a : number | boolean +>a153 : ({ a: number | boolean | undefined; } & {})[] + +declare const a156: { mode: "shortest"; } | { mode: "longest"; padding: [boolean]; } | undefined; +>a156 : { mode: "shortest"; } | { mode: "longest"; padding: [boolean]; } | undefined +>mode : "shortest" +>mode : "longest" +>padding : [boolean] + +const a157: [number | boolean | undefined][] = Iterator.zip([[1]], a156).toArray(); +>a157 : [number | boolean | undefined][] +>Iterator.zip([[1]], a156).toArray() : [number | boolean | undefined][] +>Iterator.zip([[1]], a156).toArray : () => [number | boolean | undefined][] +>Iterator.zip([[1]], a156) : IteratorObject<[number | boolean | undefined], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1]] : [number[]] +>[1] : number[] +>1 : 1 +>a156 : { mode: "shortest"; } | { mode: "longest"; padding: [boolean]; } | undefined +>toArray : () => [number | boolean | undefined][] + +const a158: [number][] = Iterator.zip([[1]], { mode: undefined }).toArray(); +>a158 : [number][] +>Iterator.zip([[1]], { mode: undefined }).toArray() : [number][] +>Iterator.zip([[1]], { mode: undefined }).toArray : () => [number][] +>Iterator.zip([[1]], { mode: undefined }) : IteratorObject<[number], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1]] : [number[]] +>[1] : number[] +>1 : 1 +>{ mode: undefined } : { mode: undefined; } +>mode : undefined +>undefined : undefined +>toArray : () => [number][] + +const a159: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: undefined }).toArray(); +>a159 : { a: number | undefined; }[] +>a : number | undefined +>Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: undefined }).toArray() : ({ a: number | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: undefined }).toArray : () => ({ a: number | undefined; } & {})[] +>Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: undefined }) : IteratorObject<{ a: number | undefined; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>{ a: [1] } : { a: number[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>{ mode: "longest", padding: undefined } : { mode: "longest"; padding: undefined; } +>mode : "longest" +>"longest" : "longest" +>padding : undefined +>undefined : undefined +>toArray : () => ({ a: number | undefined; } & {})[] + +const a160: { a: number | { b: string; }; [a1]: boolean | string; }[] = Iterator.zipKeyed({ a: [1], [a1]: [true, false] }, { +>a160 : { a: number | { b: string; }; [a1]: boolean | string; }[] +>a : number | { b: string; } +>b : string +>[a1] : string | boolean +>a1 : unique symbol +>Iterator.zipKeyed({ a: [1], [a1]: [true, false] }, { mode: "longest", padding: { a: { b: "a" }, [a1]: "a" },}).toArray() : ({ a: number | { b: string; }; [a1]: string | boolean; } & {})[] +>Iterator.zipKeyed({ a: [1], [a1]: [true, false] }, { mode: "longest", padding: { a: { b: "a" }, [a1]: "a" },}).toArray : () => ({ a: number | { b: string; }; [a1]: string | boolean; } & {})[] +>Iterator.zipKeyed({ a: [1], [a1]: [true, false] }, { mode: "longest", padding: { a: { b: "a" }, [a1]: "a" },}) : IteratorObject<{ a: number | { b: string; }; [a1]: string | boolean; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>{ a: [1], [a1]: [true, false] } : { a: number[]; [a1]: boolean[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>[a1] : boolean[] +>a1 : unique symbol +>[true, false] : boolean[] +>true : true +>false : false +>{ mode: "longest", padding: { a: { b: "a" }, [a1]: "a" },} : { mode: "longest"; padding: { a: { b: string; }; [a1]: string; }; } + + mode: "longest", +>mode : "longest" +>"longest" : "longest" + + padding: { a: { b: "a" }, [a1]: "a" }, +>padding : { a: { b: string; }; [a1]: string; } +>{ a: { b: "a" }, [a1]: "a" } : { a: { b: string; }; [a1]: string; } +>a : { b: string; } +>{ b: "a" } : { b: string; } +>b : string +>"a" : "a" +>[a1] : string +>a1 : unique symbol +>"a" : "a" + +}).toArray(); +>toArray : () => ({ a: number | { b: string; }; [a1]: string | boolean; } & {})[] + +const a161: { "0": number | boolean; }[] = Iterator.zipKeyed({ "0": [1] }, { mode: "longest", padding: { 0: false } }).toArray(); +>a161 : { "0": number | boolean; }[] +>"0" : number | boolean +>Iterator.zipKeyed({ "0": [1] }, { mode: "longest", padding: { 0: false } }).toArray() : ({ "0": number | boolean; } & {})[] +>Iterator.zipKeyed({ "0": [1] }, { mode: "longest", padding: { 0: false } }).toArray : () => ({ "0": number | boolean; } & {})[] +>Iterator.zipKeyed({ "0": [1] }, { mode: "longest", padding: { 0: false } }) : IteratorObject<{ "0": number | boolean; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>{ "0": [1] } : { "0": number[]; } +>"0" : number[] +>[1] : number[] +>1 : 1 +>{ mode: "longest", padding: { 0: false } } : { mode: "longest"; padding: { 0: false; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { 0: false; } +>{ 0: false } : { 0: false; } +>0 : false +>false : false +>toArray : () => ({ "0": number | boolean; } & {})[] + +const a162: { 0: number | boolean; }[] = Iterator.zipKeyed({ 0: [1] }, { mode: "longest", padding: { "0": false } }).toArray(); +>a162 : { 0: number | boolean; }[] +>0 : number | boolean +>Iterator.zipKeyed({ 0: [1] }, { mode: "longest", padding: { "0": false } }).toArray() : ({ 0: number | boolean; } & {})[] +>Iterator.zipKeyed({ 0: [1] }, { mode: "longest", padding: { "0": false } }).toArray : () => ({ 0: number | boolean; } & {})[] +>Iterator.zipKeyed({ 0: [1] }, { mode: "longest", padding: { "0": false } }) : IteratorObject<{ 0: number | boolean; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>{ 0: [1] } : { 0: number[]; } +>0 : number[] +>[1] : number[] +>1 : 1 +>{ mode: "longest", padding: { "0": false } } : { mode: "longest"; padding: { "0": false; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { "0": false; } +>{ "0": false } : { "0": false; } +>"0" : false +>false : false +>toArray : () => ({ 0: number | boolean; } & {})[] + +const a163 = Iterator.zipKeyed({ 0: [1] }, { mode: "longest", padding: { "01": false } }).toArray(); +>a163 : ({ 0: number | undefined; } & {})[] +>Iterator.zipKeyed({ 0: [1] }, { mode: "longest", padding: { "01": false } }).toArray() : ({ 0: number | undefined; } & {})[] +>Iterator.zipKeyed({ 0: [1] }, { mode: "longest", padding: { "01": false } }).toArray : () => ({ 0: number | undefined; } & {})[] +>Iterator.zipKeyed({ 0: [1] }, { mode: "longest", padding: { "01": false } }) : IteratorObject<{ 0: number | undefined; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>{ 0: [1] } : { 0: number[]; } +>0 : number[] +>[1] : number[] +>1 : 1 +>{ mode: "longest", padding: { "01": false } } : { mode: "longest"; padding: { "01": false; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { "01": false; } +>{ "01": false } : { "01": false; } +>"01" : false +>false : false +>toArray : () => ({ 0: number | undefined; } & {})[] + +const a164: { 0: number | undefined; }[] = a163; +>a164 : { 0: number | undefined; }[] +>0 : number | undefined +>a163 : ({ 0: number | undefined; } & {})[] + +const a165: { 0: number; }[] = a163; +>a165 : { 0: number; }[] +>0 : number +>a163 : ({ 0: number | undefined; } & {})[] + +declare const a166: Record; +>a166 : Record + +const a167 = Iterator.zipKeyed({ NaN: [1], Infinity: [2], "-Infinity": [3] }, { mode: "longest", padding: a166 }).toArray(); +>a167 : ({ NaN: number | boolean | undefined; Infinity: number | boolean | undefined; "-Infinity": number | boolean | undefined; } & {})[] +>Iterator.zipKeyed({ NaN: [1], Infinity: [2], "-Infinity": [3] }, { mode: "longest", padding: a166 }).toArray() : ({ NaN: number | boolean | undefined; Infinity: number | boolean | undefined; "-Infinity": number | boolean | undefined; } & {})[] +>Iterator.zipKeyed({ NaN: [1], Infinity: [2], "-Infinity": [3] }, { mode: "longest", padding: a166 }).toArray : () => ({ NaN: number | boolean | undefined; Infinity: number | boolean | undefined; "-Infinity": number | boolean | undefined; } & {})[] +>Iterator.zipKeyed({ NaN: [1], Infinity: [2], "-Infinity": [3] }, { mode: "longest", padding: a166 }) : IteratorObject<{ NaN: number | boolean | undefined; Infinity: number | boolean | undefined; "-Infinity": number | boolean | undefined; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>{ NaN: [1], Infinity: [2], "-Infinity": [3] } : { NaN: number[]; Infinity: number[]; "-Infinity": number[]; } +>NaN : number[] +>[1] : number[] +>1 : 1 +>Infinity : number[] +>[2] : number[] +>2 : 2 +>"-Infinity" : number[] +>[3] : number[] +>3 : 3 +>{ mode: "longest", padding: a166 } : { mode: "longest"; padding: Record; } +>mode : "longest" +>"longest" : "longest" +>padding : Record +>a166 : Record +>toArray : () => ({ NaN: number | boolean | undefined; Infinity: number | boolean | undefined; "-Infinity": number | boolean | undefined; } & {})[] + +const a168: { NaN: number | boolean | undefined; Infinity: number | boolean | undefined; "-Infinity": number | boolean | undefined; }[] = a167; +>a168 : { NaN: number | boolean | undefined; Infinity: number | boolean | undefined; "-Infinity": number | boolean | undefined; }[] +>NaN : number | boolean | undefined +>Infinity : number | boolean | undefined +>"-Infinity" : number | boolean | undefined +>a167 : ({ NaN: number | boolean | undefined; Infinity: number | boolean | undefined; "-Infinity": number | boolean | undefined; } & {})[] + +const a169: { NaN: number | undefined; Infinity: number | undefined; "-Infinity": number | undefined; }[] = a167; +>a169 : { NaN: number | undefined; Infinity: number | undefined; "-Infinity": number | undefined; }[] +>NaN : number | undefined +>Infinity : number | undefined +>"-Infinity" : number | undefined +>a167 : ({ NaN: number | boolean | undefined; Infinity: number | boolean | undefined; "-Infinity": number | boolean | undefined; } & {})[] + +const a170 = Iterator.zipKeyed(a58, { mode: "longest", padding: { a: false } }).toArray(); +>a170 : ({ [x: string]: number | boolean | undefined; } & {})[] +>Iterator.zipKeyed(a58, { mode: "longest", padding: { a: false } }).toArray() : ({ [x: string]: number | boolean | undefined; } & {})[] +>Iterator.zipKeyed(a58, { mode: "longest", padding: { a: false } }).toArray : () => ({ [x: string]: number | boolean | undefined; } & {})[] +>Iterator.zipKeyed(a58, { mode: "longest", padding: { a: false } }) : IteratorObject<{ [x: string]: number | boolean | undefined; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>a58 : Record> +>{ mode: "longest", padding: { a: false } } : { mode: "longest"; padding: { a: false; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: false; } +>{ a: false } : { a: false; } +>a : false +>false : false +>toArray : () => ({ [x: string]: number | boolean | undefined; } & {})[] + +const a171: Record[] = a170; +>a171 : Record[] +>a170 : ({ [x: string]: number | boolean | undefined; } & {})[] + +const a172: Record[] = a170; +>a172 : Record[] +>a170 : ({ [x: string]: number | boolean | undefined; } & {})[] + +const a173: [number | undefined, string | undefined][] = Iterator.zip<[Iterable, Iterable]>([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); +>a173 : [number | undefined, string | undefined][] +>Iterator.zip<[Iterable, Iterable]>([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray() : [number | undefined, string | undefined][] +>Iterator.zip<[Iterable, Iterable]>([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray : () => [number | undefined, string | undefined][] +>Iterator.zip<[Iterable, Iterable]>([[1], ["a"]], { mode: "longest", padding: [0, ""] }) : IteratorObject<[number | undefined, string | undefined], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] : [number[], string[]] +>[1] : number[] +>1 : 1 +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: [0, ""] } : { mode: "longest"; padding: [number, string]; } +>mode : "longest" +>"longest" : "longest" +>padding : [number, string] +>[0, ""] : [number, string] +>0 : 0 +>"" : "" +>toArray : () => [number | undefined, string | undefined][] + +const a174: (number | undefined)[][] = Iterator.zip>(a12, { mode: "longest", padding: [0] }).toArray(); +>a174 : (number | undefined)[][] +>Iterator.zip>(a12, { mode: "longest", padding: [0] }).toArray() : (number | undefined)[][] +>Iterator.zip>(a12, { mode: "longest", padding: [0] }).toArray : () => (number | undefined)[][] +>Iterator.zip>(a12, { mode: "longest", padding: [0] }) : IteratorObject<(number | undefined)[], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>a12 : Iterable> +>{ mode: "longest", padding: [0] } : { mode: "longest"; padding: number[]; } +>mode : "longest" +>"longest" : "longest" +>padding : number[] +>[0] : number[] +>0 : 0 +>toArray : () => (number | undefined)[][] + +const a175: { a: number | undefined; }[] = Iterator.zipKeyed<{ a: Iterable; }>({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray(); +>a175 : { a: number | undefined; }[] +>a : number | undefined +>Iterator.zipKeyed<{ a: Iterable; }>({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray() : ({ a: number | undefined; } & {})[] +>Iterator.zipKeyed<{ a: Iterable; }>({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray : () => ({ a: number | undefined; } & {})[] +>Iterator.zipKeyed<{ a: Iterable; }>({ a: [1] }, { mode: "longest", padding: { a: 0 } }) : IteratorObject<{ a: number | undefined; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>a : Iterable +>{ a: [1] } : { a: number[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>{ mode: "longest", padding: { a: 0 } } : { mode: "longest"; padding: { a: number; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: number; } +>{ a: 0 } : { a: number; } +>a : number +>0 : 0 +>toArray : () => ({ a: number | undefined; } & {})[] + +const a176: [number | boolean][] = Iterator.zip<[Iterable], [boolean]>([[1]], { mode: "longest", padding: [false] }).toArray(); +>a176 : [number | boolean][] +>Iterator.zip<[Iterable], [boolean]>([[1]], { mode: "longest", padding: [false] }).toArray() : [number | boolean][] +>Iterator.zip<[Iterable], [boolean]>([[1]], { mode: "longest", padding: [false] }).toArray : () => [number | boolean][] +>Iterator.zip<[Iterable], [boolean]>([[1]], { mode: "longest", padding: [false] }) : IteratorObject<[number | boolean], undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1]] : [number[]] +>[1] : number[] +>1 : 1 +>{ mode: "longest", padding: [false] } : { mode: "longest"; padding: [false]; } +>mode : "longest" +>"longest" : "longest" +>padding : [false] +>[false] : [false] +>false : false +>toArray : () => [number | boolean][] + +const a177: { a: number | boolean; }[] = Iterator.zipKeyed<{ a: Iterable; }, { a: boolean; }>({ a: [1] }, { mode: "longest", padding: { a: false } }).toArray(); +>a177 : { a: number | boolean; }[] +>a : number | boolean +>Iterator.zipKeyed<{ a: Iterable; }, { a: boolean; }>({ a: [1] }, { mode: "longest", padding: { a: false } }).toArray() : ({ a: number | boolean; } & {})[] +>Iterator.zipKeyed<{ a: Iterable; }, { a: boolean; }>({ a: [1] }, { mode: "longest", padding: { a: false } }).toArray : () => ({ a: number | boolean; } & {})[] +>Iterator.zipKeyed<{ a: Iterable; }, { a: boolean; }>({ a: [1] }, { mode: "longest", padding: { a: false } }) : IteratorObject<{ a: number | boolean; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>a : Iterable +>a : boolean +>{ a: [1] } : { a: number[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>{ mode: "longest", padding: { a: false } } : { mode: "longest"; padding: { a: false; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: false; } +>{ a: false } : { a: false; } +>a : false +>false : false +>toArray : () => ({ a: number | boolean; } & {})[] + +Iterator.zipKeyed<{ a: Iterable; }>({ a: [1] }, { mode: "longest", padding: 0 }); +>Iterator.zipKeyed<{ a: Iterable; }>({ a: [1] }, { mode: "longest", padding: 0 }) : IteratorObject<{ a: number; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>a : Iterable +>{ a: [1] } : { a: number[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>{ mode: "longest", padding: 0 } : { mode: "longest"; padding: number; } +>mode : "longest" +>"longest" : "longest" +>padding : number +>0 : 0 + +Iterator.zipKeyed<{}>({}, { mode: "longest", padding: 0 }); +>Iterator.zipKeyed<{}>({}, { mode: "longest", padding: 0 }) : IteratorObject, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>{} : {} +>{ mode: "longest", padding: 0 } : { mode: "longest"; padding: number; } +>mode : "longest" +>"longest" : "longest" +>padding : number +>0 : 0 + +Iterator.zipKeyed<{ a: Iterable; }, {}>({ a: [1] }, { mode: "longest", padding: 0 }); +>Iterator.zipKeyed<{ a: Iterable; }, {}>({ a: [1] }, { mode: "longest", padding: 0 }) : IteratorObject<{ a: number; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>a : Iterable +>{ a: [1] } : { a: number[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>{ mode: "longest", padding: 0 } : { mode: "longest"; padding: number; } +>mode : "longest" +>"longest" : "longest" +>padding : number +>0 : 0 + +=== b.ts === +export function f1>>(a: T) { +>f1 : >>(a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown> +>a : T + + return Iterator.zipKeyed(a); +>Iterator.zipKeyed(a) : IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>a : T +} + +export function f2>>(a: T) { +>f2 : >>(a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> extends infer T_2 ? T_2 extends Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> as {} extends Pick | Iterator) & object ? U : never : never : never) | undefined; }>, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> extends infer T_2 ? T_2 extends Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> as {} extends Pick | Iterator) & object ? U : never : never : never) | undefined; }>, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown> +>a : T + + return Iterator.zipKeyed(a, { mode: "longest" }); +>Iterator.zipKeyed(a, { mode: "longest" }) : IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> extends infer T_2 ? T_2 extends Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> as {} extends Pick | Iterator) & object ? U : never : never : never) | undefined; }>, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> extends infer T_2 ? T_2 extends Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> as {} extends Pick | Iterator) & object ? U : never : never : never) | undefined; }>, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>a : T +>{ mode: "longest" } : { mode: "longest"; } +>mode : "longest" +>"longest" : "longest" +} + +export function f3>>(a: T) { +>f3 : >>(a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : undefined); }, undefined, unknown> +>a : T + + return Iterator.zipKeyed(a, { mode: "longest", padding: {} }); +>Iterator.zipKeyed(a, { mode: "longest", padding: {} }) : IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : undefined); }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>a : T +>{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } +>mode : "longest" +>"longest" : "longest" +>padding : {} +>{} : {} +} + +export function f4(a: T) { +>f4 : (a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown> +>a : T + + return Iterator.zipKeyed(a); +>Iterator.zipKeyed(a) : IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>a : T +} + +export function f5(a: Iterable, b: U) { +>f5 : (a: Iterable, b: U) => IteratorObject<{ a: T | U; } & {}, undefined, unknown> +>a : Iterable +>b : U + + return Iterator.zipKeyed({ a }, { mode: "longest", padding: { a: b } }); +>Iterator.zipKeyed({ a }, { mode: "longest", padding: { a: b } }) : IteratorObject<{ a: T | U; } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U_1 : never : never : never) | undefined; }>(iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U_1 : never : never : never) | undefined; }>(iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>{ a } : { a: Iterable; } +>a : Iterable +>{ mode: "longest", padding: { a: b } } : { mode: "longest"; padding: { a: U; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: U; } +>{ a: b } : { a: U; } +>a : U +>b : U +} + +export function f6 | Iterator)[]>(a: T) { +>f6 : | Iterator)[]>(a: T) => IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown> +>a : T + + return Iterator.zip(a); +>Iterator.zip(a) : IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown> +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T_1, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T_1, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T_1, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T_1 extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T_1 extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T_1 extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T_1, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T_1, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T_1, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T_1 extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T_1 extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T_1 extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>a : T +} + +export function f7(a: Iterable, b: U) { +>f7 : (a: Iterable, b: U) => IteratorObject<{ a: T | (U extends unknown ? U["a" & keyof U] : never) | ("a" extends keyof { [K in keyof U as {} extends Pick ? never : K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K]: unknown; } ? never : undefined); } & {}, undefined, unknown> +>a : Iterable +>b : U + + return Iterator.zipKeyed({ a }, { mode: "longest", padding: b }); +>Iterator.zipKeyed({ a }, { mode: "longest", padding: b }) : IteratorObject<{ a: T | (U extends unknown ? U["a" & keyof U] : never) | ("a" extends keyof { [K in keyof U as {} extends Pick ? never : K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K]: unknown; } ? never : undefined); } & {}, undefined, unknown> +>Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U_1 : never : never : never) | undefined; }>(iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U_1 : never : never : never) | undefined; }>(iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (Partial extends infer T_3 ? T_3 extends Partial ? T_3 extends unknown ? T_3[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_3] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_3[number & keyof T_3] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>{ a } : { a: Iterable; } +>a : Iterable +>{ mode: "longest", padding: b } : { mode: "longest"; padding: U; } +>mode : "longest" +>"longest" : "longest" +>padding : U +>b : U +} + +export const a = f1({ a: [1], b: ["a"] }).toArray(); +>a : ({ a: number; b: string; } & {})[] +>f1({ a: [1], b: ["a"] }).toArray() : ({ a: number; b: string; } & {})[] +>f1({ a: [1], b: ["a"] }).toArray : () => ({ a: number; b: string; } & {})[] +>f1({ a: [1], b: ["a"] }) : IteratorObject<{ a: number; b: string; } & {}, undefined, unknown> +>f1 : >>(a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown> +>{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : string[] +>["a"] : string[] +>"a" : "a" +>toArray : () => ({ a: number; b: string; } & {})[] + +export const b = f2({ a: [1], b: ["a"] }).toArray(); +>b : ({ a: number | undefined; b: string | undefined; } & {})[] +>f2({ a: [1], b: ["a"] }).toArray() : ({ a: number | undefined; b: string | undefined; } & {})[] +>f2({ a: [1], b: ["a"] }).toArray : () => ({ a: number | undefined; b: string | undefined; } & {})[] +>f2({ a: [1], b: ["a"] }) : IteratorObject<{ a: number | undefined; b: string | undefined; } & {}, undefined, unknown> +>f2 : >>(a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> extends infer T_2 ? T_2 extends Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> as {} extends Pick | Iterator) & object ? U : never : never : never) | undefined; }>, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> extends infer T_2 ? T_2 extends Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial<{ readonly [K_1 in keyof T]?: (T[K_1] extends infer T_2 ? T_2 extends T[K_1] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }> as {} extends Pick | Iterator) & object ? U : never : never : never) | undefined; }>, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown> +>{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : string[] +>["a"] : string[] +>"a" : "a" +>toArray : () => ({ a: number | undefined; b: string | undefined; } & {})[] + +export const c = f3({ a: [1], b: ["a"] }).toArray(); +>c : ({ a: number | undefined; b: string | undefined; } & {})[] +>f3({ a: [1], b: ["a"] }).toArray() : ({ a: number | undefined; b: string | undefined; } & {})[] +>f3({ a: [1], b: ["a"] }).toArray : () => ({ a: number | undefined; b: string | undefined; } & {})[] +>f3({ a: [1], b: ["a"] }) : IteratorObject<{ a: number | undefined; b: string | undefined; } & {}, undefined, unknown> +>f3 : >>(a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : undefined); }, undefined, unknown> +>{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : string[] +>["a"] : string[] +>"a" : "a" +>toArray : () => ({ a: number | undefined; b: string | undefined; } & {})[] + +export const d = f4({ a: [1], b: ["a"] }).toArray(); +>d : ({ a: number; b: string; } & {})[] +>f4({ a: [1], b: ["a"] }).toArray() : ({ a: number; b: string; } & {})[] +>f4({ a: [1], b: ["a"] }).toArray : () => ({ a: number; b: string; } & {})[] +>f4({ a: [1], b: ["a"] }) : IteratorObject<{ a: number; b: string; } & {}, undefined, unknown> +>f4 : (a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown> +>{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : string[] +>["a"] : string[] +>"a" : "a" +>toArray : () => ({ a: number; b: string; } & {})[] + +export const e = f5([1], false).toArray(); +>e : ({ a: number | boolean; } & {})[] +>f5([1], false).toArray() : ({ a: number | boolean; } & {})[] +>f5([1], false).toArray : () => ({ a: number | boolean; } & {})[] +>f5([1], false) : IteratorObject<{ a: number | boolean; } & {}, undefined, unknown> +>f5 : (a: Iterable, b: U) => IteratorObject<{ a: T | U; } & {}, undefined, unknown> +>[1] : number[] +>1 : 1 +>false : false +>toArray : () => ({ a: number | boolean; } & {})[] + +export const f = f6([[1], ["a"]] as const).toArray(); +>f : [1, "a"][] +>f6([[1], ["a"]] as const).toArray() : [1, "a"][] +>f6([[1], ["a"]] as const).toArray : () => [1, "a"][] +>f6([[1], ["a"]] as const) : IteratorObject<[1, "a"], undefined, unknown> +>f6 : | Iterator)[]>(a: T) => IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown> +>[[1], ["a"]] as const : readonly [readonly [1], readonly ["a"]] +>[[1], ["a"]] : readonly [readonly [1], readonly ["a"]] +>[1] : readonly [1] +>1 : 1 +>["a"] : readonly ["a"] +>"a" : "a" +>toArray : () => [1, "a"][] + +export const g = f7([1], { a: false }).toArray(); +>g : ({ a: number | boolean; } & {})[] +>f7([1], { a: false }).toArray() : ({ a: number | boolean; } & {})[] +>f7([1], { a: false }).toArray : () => ({ a: number | boolean; } & {})[] +>f7([1], { a: false }) : IteratorObject<{ a: number | boolean; } & {}, undefined, unknown> +>f7 : (a: Iterable, b: U) => IteratorObject<{ a: T | (U extends unknown ? U["a" & keyof U] : never) | ("a" extends keyof { [K in keyof U as {} extends Pick ? never : K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K]: unknown; } ? never : undefined); } & {}, undefined, unknown> +>[1] : number[] +>1 : 1 +>{ a: false } : { a: false; } +>a : false +>false : false +>toArray : () => ({ a: number | boolean; } & {})[] + +export const h = Iterator.zip; +>h : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator.zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>Iterator : IteratorConstructor +>zip : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } + +export const i = Iterator.zipKeyed; +>i : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator.zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>Iterator : IteratorConstructor +>zipKeyed : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } + +export const j = h([[1], ["a"]], { mode: "longest", padding: [false, false] }).toArray(); +>j : [number | boolean, string | boolean][] +>h([[1], ["a"]], { mode: "longest", padding: [false, false] }).toArray() : [number | boolean, string | boolean][] +>h([[1], ["a"]], { mode: "longest", padding: [false, false] }).toArray : () => [number | boolean, string | boolean][] +>h([[1], ["a"]], { mode: "longest", padding: [false, false] }) : IteratorObject<[number | boolean, string | boolean], undefined, unknown> +>h : { (iterables: readonly [], options?: { mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject; | Iterator) & object)[] | []>(iterables: T, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | [] = { readonly [K in keyof T]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject<(T extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object, TPadding = T extends (Iterable | Iterator) & object ? U : never>(iterables: Iterable & object, options?: ({ mode: "longest"; padding?: (Iterable & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject<(TPadding | (T extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } +>[[1], ["a"]] : [number[], string[]] +>[1] : number[] +>1 : 1 +>["a"] : string[] +>"a" : "a" +>{ mode: "longest", padding: [false, false] } : { mode: "longest"; padding: [false, false]; } +>mode : "longest" +>"longest" : "longest" +>padding : [false, false] +>[false, false] : [false, false] +>false : false +>false : false +>toArray : () => [number | boolean, string | boolean][] + +export const k = i({ a: [1], b: [2, 3] }, { mode: "longest", padding: { a: false } }).toArray(); +>k : ({ a: number | boolean; b: number | undefined; } & {})[] +>i({ a: [1], b: [2, 3] }, { mode: "longest", padding: { a: false } }).toArray() : ({ a: number | boolean; b: number | undefined; } & {})[] +>i({ a: [1], b: [2, 3] }, { mode: "longest", padding: { a: false } }).toArray : () => ({ a: number | boolean; b: number | undefined; } & {})[] +>i({ a: [1], b: [2, 3] }, { mode: "longest", padding: { a: false } }) : IteratorObject<{ a: number | boolean; b: number | undefined; } & {}, undefined, unknown> +>i : { (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends "-Infinity" | "Infinity" | "NaN" ? never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends never ? never : never); }, undefined, unknown>; (iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options: { mode: "longest"; padding?: (TPadding & object) | undefined; } & { padding: TPadding; }): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (TPadding extends unknown ? TPadding[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof TPadding] | (K extends "-Infinity" | "Infinity" | "NaN" ? TPadding[number & keyof TPadding] : never) : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object ? U : never : never : never) | undefined; }>(iterables: T & { [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: ({ mode: "longest"; padding?: (TPadding & object) | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }) | undefined): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (Partial extends infer T_2 ? T_2 extends Partial ? T_2 extends unknown ? T_2[(K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) & keyof T_2] | (K extends "-Infinity" | "Infinity" | "NaN" ? T_2[number & keyof T_2] : never) : never : never : never) | ((K extends number ? `${K}` | K | (number extends K ? "-Infinity" | "Infinity" | "NaN" : never) : K extends `${infer N extends number}` ? `${N}` extends K ? N | K : K : K) extends keyof { [K_1 in keyof Partial as {} extends Pick, K_1> ? never : K_1 extends number ? `${K_1}` | K_1 | (number extends K_1 ? "-Infinity" | "Infinity" | "NaN" : never) : K_1 extends `${infer N extends number}` ? `${N}` extends K_1 ? N | K_1 : K_1 : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T & ([T] extends [{ [K in T extends unknown ? keyof T : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: { mode: "longest"; padding?: object | undefined; } | { mode?: "shortest" | undefined; } | { mode: "strict"; }): IteratorObject, undefined, unknown>; } +>{ a: [1], b: [2, 3] } : { a: number[]; b: number[]; } +>a : number[] +>[1] : number[] +>1 : 1 +>b : number[] +>[2, 3] : number[] +>2 : 2 +>3 : 3 +>{ mode: "longest", padding: { a: false } } : { mode: "longest"; padding: { a: false; }; } +>mode : "longest" +>"longest" : "longest" +>padding : { a: false; } +>{ a: false } : { a: false; } +>a : false +>false : false +>toArray : () => ({ a: number | boolean; b: number | undefined; } & {})[] diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=false).js b/tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=false).js deleted file mode 100644 index 257ec6471ed72..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=false).js +++ /dev/null @@ -1,108 +0,0 @@ -//// [tests/cases/compiler/iteratorZipDeclarations.ts] //// - -//// [iteratorZipDeclarations.ts] -export function f1>>(a: T) { - return Iterator.zipKeyed(a); -} - -export function f2>>(a: T) { - return Iterator.zipKeyed(a, { mode: "longest" }); -} - -export function f3>>(a: T) { - return Iterator.zipKeyed(a, { mode: "longest", padding: {} }); -} - -export function f4(a: T) { - return Iterator.zipKeyed(a); -} - -export function f5(a: Iterable, b: T) { - return Iterator.zipKeyed({ a }, { mode: "longest", padding: { a: b } }); -} - -export function f6 | Iterator)[]>(a: T) { - return Iterator.zip(a); -} - -export function f7(a: Iterable, b: U) { - return Iterator.zipKeyed({ a }, { mode: "longest", padding: b }); -} - -export const a = f1({ a: [1], b: ["a"] }).toArray(); -export const b = f2({ a: [1], b: ["a"] }).toArray(); -export const c = f3({ a: [1], b: ["a"] }).toArray(); -export const d = f4({ a: [1], b: ["a"] }).toArray(); -export const e = f5([1], 0).toArray(); -export const f = f6([[1], ["a"]] as const).toArray(); -export const g = f7([1], { a: 0 }).toArray(); - - -//// [iteratorZipDeclarations.js] -export function f1(a) { - return Iterator.zipKeyed(a); -} -export function f2(a) { - return Iterator.zipKeyed(a, { mode: "longest" }); -} -export function f3(a) { - return Iterator.zipKeyed(a, { mode: "longest", padding: {} }); -} -export function f4(a) { - return Iterator.zipKeyed(a); -} -export function f5(a, b) { - return Iterator.zipKeyed({ a }, { mode: "longest", padding: { a: b } }); -} -export function f6(a) { - return Iterator.zip(a); -} -export function f7(a, b) { - return Iterator.zipKeyed({ a }, { mode: "longest", padding: b }); -} -export const a = f1({ a: [1], b: ["a"] }).toArray(); -export const b = f2({ a: [1], b: ["a"] }).toArray(); -export const c = f3({ a: [1], b: ["a"] }).toArray(); -export const d = f4({ a: [1], b: ["a"] }).toArray(); -export const e = f5([1], 0).toArray(); -export const f = f6([[1], ["a"]]).toArray(); -export const g = f7([1], { a: 0 }).toArray(); - - -//// [iteratorZipDeclarations.d.ts] -export declare function f1>>(a: T): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; -export declare function f2>>(a: T): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; -export declare function f3>>(a: T): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; -export declare function f4(a: T): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; -export declare function f5(a: Iterable, b: T): IteratorObject<{ - a: T; -} & {}, undefined, unknown>; -export declare function f6 | Iterator)[]>(a: T): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; -export declare function f7(a: Iterable, b: U): IteratorObject<{ - a: T | ("a" extends infer T_1 ? T_1 extends "a" ? T_1 extends keyof U ? U[T_1] : never : never : never) | ("a" extends infer T_2 ? T_2 extends "a" ? T_2 extends keyof { [K in keyof U as {} extends Pick ? never : K]: unknown; } ? never : undefined : never : never); -} & {}, undefined, unknown>; -export declare const a: ({ - a: number; - b: string; -} & {})[]; -export declare const b: ({ - a: number | undefined; - b: string | undefined; -} & {})[]; -export declare const c: ({ - a: number | undefined; - b: string | undefined; -} & {})[]; -export declare const d: ({ - a: number; - b: string; -} & {})[]; -export declare const e: ({ - a: number; -} & {})[]; -export declare const f: [1, "a"][]; -export declare const g: ({ - a: number; -} & {})[]; diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=false).symbols b/tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=false).symbols deleted file mode 100644 index 0908a94f18793..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=false).symbols +++ /dev/null @@ -1,173 +0,0 @@ -//// [tests/cases/compiler/iteratorZipDeclarations.ts] //// - -=== iteratorZipDeclarations.ts === -export function f1>>(a: T) { ->f1 : Symbol(f1, Decl(iteratorZipDeclarations.ts, 0, 0)) ->T : Symbol(T, Decl(iteratorZipDeclarations.ts, 0, 19)) ->Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 0, 64)) ->T : Symbol(T, Decl(iteratorZipDeclarations.ts, 0, 19)) - - return Iterator.zipKeyed(a); ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 0, 64)) -} - -export function f2>>(a: T) { ->f2 : Symbol(f2, Decl(iteratorZipDeclarations.ts, 2, 1)) ->T : Symbol(T, Decl(iteratorZipDeclarations.ts, 4, 19)) ->Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 4, 64)) ->T : Symbol(T, Decl(iteratorZipDeclarations.ts, 4, 19)) - - return Iterator.zipKeyed(a, { mode: "longest" }); ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 4, 64)) ->mode : Symbol(mode, Decl(iteratorZipDeclarations.ts, 5, 33)) -} - -export function f3>>(a: T) { ->f3 : Symbol(f3, Decl(iteratorZipDeclarations.ts, 6, 1)) ->T : Symbol(T, Decl(iteratorZipDeclarations.ts, 8, 19)) ->Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 8, 64)) ->T : Symbol(T, Decl(iteratorZipDeclarations.ts, 8, 19)) - - return Iterator.zipKeyed(a, { mode: "longest", padding: {} }); ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 8, 64)) ->mode : Symbol(mode, Decl(iteratorZipDeclarations.ts, 9, 33)) ->padding : Symbol(padding, Decl(iteratorZipDeclarations.ts, 9, 50)) -} - -export function f4(a: T) { ->f4 : Symbol(f4, Decl(iteratorZipDeclarations.ts, 10, 1)) ->T : Symbol(T, Decl(iteratorZipDeclarations.ts, 12, 19)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 12, 37)) ->T : Symbol(T, Decl(iteratorZipDeclarations.ts, 12, 19)) - - return Iterator.zipKeyed(a); ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 12, 37)) -} - -export function f5(a: Iterable, b: T) { ->f5 : Symbol(f5, Decl(iteratorZipDeclarations.ts, 14, 1)) ->T : Symbol(T, Decl(iteratorZipDeclarations.ts, 16, 19)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 16, 22)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->T : Symbol(T, Decl(iteratorZipDeclarations.ts, 16, 19)) ->b : Symbol(b, Decl(iteratorZipDeclarations.ts, 16, 37)) ->T : Symbol(T, Decl(iteratorZipDeclarations.ts, 16, 19)) - - return Iterator.zipKeyed({ a }, { mode: "longest", padding: { a: b } }); ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 17, 30)) ->mode : Symbol(mode, Decl(iteratorZipDeclarations.ts, 17, 37)) ->padding : Symbol(padding, Decl(iteratorZipDeclarations.ts, 17, 54)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 17, 65)) ->b : Symbol(b, Decl(iteratorZipDeclarations.ts, 16, 37)) -} - -export function f6 | Iterator)[]>(a: T) { ->f6 : Symbol(f6, Decl(iteratorZipDeclarations.ts, 18, 1)) ->T : Symbol(T, Decl(iteratorZipDeclarations.ts, 20, 19)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 20, 81)) ->T : Symbol(T, Decl(iteratorZipDeclarations.ts, 20, 19)) - - return Iterator.zip(a); ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 20, 81)) -} - -export function f7(a: Iterable, b: U) { ->f7 : Symbol(f7, Decl(iteratorZipDeclarations.ts, 22, 1)) ->T : Symbol(T, Decl(iteratorZipDeclarations.ts, 24, 19)) ->U : Symbol(U, Decl(iteratorZipDeclarations.ts, 24, 21)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 24, 33)) ->T : Symbol(T, Decl(iteratorZipDeclarations.ts, 24, 19)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 24, 44)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->T : Symbol(T, Decl(iteratorZipDeclarations.ts, 24, 19)) ->b : Symbol(b, Decl(iteratorZipDeclarations.ts, 24, 59)) ->U : Symbol(U, Decl(iteratorZipDeclarations.ts, 24, 21)) - - return Iterator.zipKeyed({ a }, { mode: "longest", padding: b }); ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 25, 30)) ->mode : Symbol(mode, Decl(iteratorZipDeclarations.ts, 25, 37)) ->padding : Symbol(padding, Decl(iteratorZipDeclarations.ts, 25, 54)) ->b : Symbol(b, Decl(iteratorZipDeclarations.ts, 24, 59)) -} - -export const a = f1({ a: [1], b: ["a"] }).toArray(); ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 28, 12)) ->f1({ a: [1], b: ["a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->f1 : Symbol(f1, Decl(iteratorZipDeclarations.ts, 0, 0)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 28, 21)) ->b : Symbol(b, Decl(iteratorZipDeclarations.ts, 28, 29)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -export const b = f2({ a: [1], b: ["a"] }).toArray(); ->b : Symbol(b, Decl(iteratorZipDeclarations.ts, 29, 12)) ->f2({ a: [1], b: ["a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->f2 : Symbol(f2, Decl(iteratorZipDeclarations.ts, 2, 1)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 29, 21)) ->b : Symbol(b, Decl(iteratorZipDeclarations.ts, 29, 29)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -export const c = f3({ a: [1], b: ["a"] }).toArray(); ->c : Symbol(c, Decl(iteratorZipDeclarations.ts, 30, 12)) ->f3({ a: [1], b: ["a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->f3 : Symbol(f3, Decl(iteratorZipDeclarations.ts, 6, 1)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 30, 21)) ->b : Symbol(b, Decl(iteratorZipDeclarations.ts, 30, 29)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -export const d = f4({ a: [1], b: ["a"] }).toArray(); ->d : Symbol(d, Decl(iteratorZipDeclarations.ts, 31, 12)) ->f4({ a: [1], b: ["a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->f4 : Symbol(f4, Decl(iteratorZipDeclarations.ts, 10, 1)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 31, 21)) ->b : Symbol(b, Decl(iteratorZipDeclarations.ts, 31, 29)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -export const e = f5([1], 0).toArray(); ->e : Symbol(e, Decl(iteratorZipDeclarations.ts, 32, 12)) ->f5([1], 0).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->f5 : Symbol(f5, Decl(iteratorZipDeclarations.ts, 14, 1)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -export const f = f6([[1], ["a"]] as const).toArray(); ->f : Symbol(f, Decl(iteratorZipDeclarations.ts, 33, 12)) ->f6([[1], ["a"]] as const).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->f6 : Symbol(f6, Decl(iteratorZipDeclarations.ts, 18, 1)) ->const : Symbol(const) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -export const g = f7([1], { a: 0 }).toArray(); ->g : Symbol(g, Decl(iteratorZipDeclarations.ts, 34, 12)) ->f7([1], { a: 0 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->f7 : Symbol(f7, Decl(iteratorZipDeclarations.ts, 22, 1)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 34, 26)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=false).types b/tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=false).types deleted file mode 100644 index 3d6bd6945b07c..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=false).types +++ /dev/null @@ -1,210 +0,0 @@ -//// [tests/cases/compiler/iteratorZipDeclarations.ts] //// - -=== iteratorZipDeclarations.ts === -export function f1>>(a: T) { ->f1 : >>(a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown> ->a : T - - return Iterator.zipKeyed(a); ->Iterator.zipKeyed(a) : IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->a : T -} - -export function f2>>(a: T) { ->f2 : >>(a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown> ->a : T - - return Iterator.zipKeyed(a, { mode: "longest" }); ->Iterator.zipKeyed(a, { mode: "longest" }) : IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->a : T ->{ mode: "longest" } : { mode: "longest"; } ->mode : "longest" ->"longest" : "longest" -} - -export function f3>>(a: T) { ->f3 : >>(a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown> ->a : T - - return Iterator.zipKeyed(a, { mode: "longest", padding: {} }); ->Iterator.zipKeyed(a, { mode: "longest", padding: {} }) : IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->a : T ->{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } ->mode : "longest" ->"longest" : "longest" ->padding : {} ->{} : {} -} - -export function f4(a: T) { ->f4 : (a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown> ->a : T - - return Iterator.zipKeyed(a); ->Iterator.zipKeyed(a) : IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->a : T -} - -export function f5(a: Iterable, b: T) { ->f5 : (a: Iterable, b: T) => IteratorObject<{ a: T; } & {}, undefined, unknown> ->a : Iterable ->b : T - - return Iterator.zipKeyed({ a }, { mode: "longest", padding: { a: b } }); ->Iterator.zipKeyed({ a }, { mode: "longest", padding: { a: b } }) : IteratorObject<{ a: T; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->{ a } : { a: Iterable; } ->a : Iterable ->{ mode: "longest", padding: { a: b } } : { mode: "longest"; padding: { a: T; }; } ->mode : "longest" ->"longest" : "longest" ->padding : { a: T; } ->{ a: b } : { a: T; } ->a : T ->b : T -} - -export function f6 | Iterator)[]>(a: T) { ->f6 : | Iterator)[]>(a: T) => IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown> ->a : T - - return Iterator.zip(a); ->Iterator.zip(a) : IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T_1, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T_1, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T_1, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T_1 extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T_1 extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T_1, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T_1, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T_1, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T_1 extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T_1 extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->a : T -} - -export function f7(a: Iterable, b: U) { ->f7 : (a: Iterable, b: U) => IteratorObject<{ a: T | ("a" extends infer T_1 ? T_1 extends "a" ? T_1 extends keyof U ? U[T_1] : never : never : never) | ("a" extends infer T_2 ? T_2 extends "a" ? T_2 extends keyof { [K in keyof U as {} extends Pick ? never : K]: unknown; } ? never : undefined : never : never); } & {}, undefined, unknown> ->a : T | undefined ->a : Iterable ->b : U - - return Iterator.zipKeyed({ a }, { mode: "longest", padding: b }); ->Iterator.zipKeyed({ a }, { mode: "longest", padding: b }) : IteratorObject<{ a: T | ("a" extends infer T_1 ? T_1 extends "a" ? T_1 extends keyof U ? U[T_1] : never : never : never) | ("a" extends infer T_2 ? T_2 extends "a" ? T_2 extends keyof { [K in keyof U as {} extends Pick ? never : K]: unknown; } ? never : undefined : never : never); } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U_1 : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U_1 : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: ((T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->{ a } : { a: Iterable; } ->a : Iterable ->{ mode: "longest", padding: b } : { mode: "longest"; padding: U; } ->mode : "longest" ->"longest" : "longest" ->padding : U ->b : U -} - -export const a = f1({ a: [1], b: ["a"] }).toArray(); ->a : ({ a: number; b: string; } & {})[] ->f1({ a: [1], b: ["a"] }).toArray() : ({ a: number; b: string; } & {})[] ->f1({ a: [1], b: ["a"] }).toArray : () => ({ a: number; b: string; } & {})[] ->f1({ a: [1], b: ["a"] }) : IteratorObject<{ a: number; b: string; } & {}, undefined, unknown> ->f1 : >>(a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown> ->{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } ->a : number[] ->[1] : number[] ->1 : 1 ->b : string[] ->["a"] : string[] ->"a" : "a" ->toArray : () => ({ a: number; b: string; } & {})[] - -export const b = f2({ a: [1], b: ["a"] }).toArray(); ->b : ({ a: number | undefined; b: string | undefined; } & {})[] ->f2({ a: [1], b: ["a"] }).toArray() : ({ a: number | undefined; b: string | undefined; } & {})[] ->f2({ a: [1], b: ["a"] }).toArray : () => ({ a: number | undefined; b: string | undefined; } & {})[] ->f2({ a: [1], b: ["a"] }) : IteratorObject<{ a: number | undefined; b: string | undefined; } & {}, undefined, unknown> ->f2 : >>(a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown> ->{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } ->a : number[] ->[1] : number[] ->1 : 1 ->b : string[] ->["a"] : string[] ->"a" : "a" ->toArray : () => ({ a: number | undefined; b: string | undefined; } & {})[] - -export const c = f3({ a: [1], b: ["a"] }).toArray(); ->c : ({ a: number | undefined; b: string | undefined; } & {})[] ->f3({ a: [1], b: ["a"] }).toArray() : ({ a: number | undefined; b: string | undefined; } & {})[] ->f3({ a: [1], b: ["a"] }).toArray : () => ({ a: number | undefined; b: string | undefined; } & {})[] ->f3({ a: [1], b: ["a"] }) : IteratorObject<{ a: number | undefined; b: string | undefined; } & {}, undefined, unknown> ->f3 : >>(a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined)) | undefined; }, undefined, unknown> ->{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } ->a : number[] ->[1] : number[] ->1 : 1 ->b : string[] ->["a"] : string[] ->"a" : "a" ->toArray : () => ({ a: number | undefined; b: string | undefined; } & {})[] - -export const d = f4({ a: [1], b: ["a"] }).toArray(); ->d : ({ a: number; b: string; } & {})[] ->f4({ a: [1], b: ["a"] }).toArray() : ({ a: number; b: string; } & {})[] ->f4({ a: [1], b: ["a"] }).toArray : () => ({ a: number; b: string; } & {})[] ->f4({ a: [1], b: ["a"] }) : IteratorObject<{ a: number; b: string; } & {}, undefined, unknown> ->f4 : (a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: ((T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never)) | undefined; }, undefined, unknown> ->{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } ->a : number[] ->[1] : number[] ->1 : 1 ->b : string[] ->["a"] : string[] ->"a" : "a" ->toArray : () => ({ a: number; b: string; } & {})[] - -export const e = f5([1], 0).toArray(); ->e : ({ a: number; } & {})[] ->f5([1], 0).toArray() : ({ a: number; } & {})[] ->f5([1], 0).toArray : () => ({ a: number; } & {})[] ->f5([1], 0) : IteratorObject<{ a: number; } & {}, undefined, unknown> ->f5 : (a: Iterable, b: T) => IteratorObject<{ a: T; } & {}, undefined, unknown> ->[1] : number[] ->1 : 1 ->0 : 0 ->toArray : () => ({ a: number; } & {})[] - -export const f = f6([[1], ["a"]] as const).toArray(); ->f : [1, "a"][] ->f6([[1], ["a"]] as const).toArray() : [1, "a"][] ->f6([[1], ["a"]] as const).toArray : () => [1, "a"][] ->f6([[1], ["a"]] as const) : IteratorObject<[1, "a"], undefined, unknown> ->f6 : | Iterator)[]>(a: T) => IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown> ->[[1], ["a"]] as const : readonly [readonly [1], readonly ["a"]] ->[[1], ["a"]] : readonly [readonly [1], readonly ["a"]] ->[1] : readonly [1] ->1 : 1 ->["a"] : readonly ["a"] ->"a" : "a" ->toArray : () => [1, "a"][] - -export const g = f7([1], { a: 0 }).toArray(); ->g : ({ a: number; } & {})[] ->f7([1], { a: 0 }).toArray() : ({ a: number; } & {})[] ->f7([1], { a: 0 }).toArray : () => ({ a: number; } & {})[] ->f7([1], { a: 0 }) : IteratorObject<{ a: number; } & {}, undefined, unknown> ->f7 : (a: Iterable, b: U) => IteratorObject<{ a: T | ("a" extends infer T_1 ? T_1 extends "a" ? T_1 extends keyof U ? U[T_1] : never : never : never) | ("a" extends infer T_2 ? T_2 extends "a" ? T_2 extends keyof { [K in keyof U as {} extends Pick ? never : K]: unknown; } ? never : undefined : never : never); } & {}, undefined, unknown> ->[1] : number[] ->1 : 1 ->{ a: 0 } : { a: number; } ->a : number ->0 : 0 ->toArray : () => ({ a: number; } & {})[] - diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=true).js b/tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=true).js deleted file mode 100644 index 8ffcc3ba08d59..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=true).js +++ /dev/null @@ -1,108 +0,0 @@ -//// [tests/cases/compiler/iteratorZipDeclarations.ts] //// - -//// [iteratorZipDeclarations.ts] -export function f1>>(a: T) { - return Iterator.zipKeyed(a); -} - -export function f2>>(a: T) { - return Iterator.zipKeyed(a, { mode: "longest" }); -} - -export function f3>>(a: T) { - return Iterator.zipKeyed(a, { mode: "longest", padding: {} }); -} - -export function f4(a: T) { - return Iterator.zipKeyed(a); -} - -export function f5(a: Iterable, b: T) { - return Iterator.zipKeyed({ a }, { mode: "longest", padding: { a: b } }); -} - -export function f6 | Iterator)[]>(a: T) { - return Iterator.zip(a); -} - -export function f7(a: Iterable, b: U) { - return Iterator.zipKeyed({ a }, { mode: "longest", padding: b }); -} - -export const a = f1({ a: [1], b: ["a"] }).toArray(); -export const b = f2({ a: [1], b: ["a"] }).toArray(); -export const c = f3({ a: [1], b: ["a"] }).toArray(); -export const d = f4({ a: [1], b: ["a"] }).toArray(); -export const e = f5([1], 0).toArray(); -export const f = f6([[1], ["a"]] as const).toArray(); -export const g = f7([1], { a: 0 }).toArray(); - - -//// [iteratorZipDeclarations.js] -export function f1(a) { - return Iterator.zipKeyed(a); -} -export function f2(a) { - return Iterator.zipKeyed(a, { mode: "longest" }); -} -export function f3(a) { - return Iterator.zipKeyed(a, { mode: "longest", padding: {} }); -} -export function f4(a) { - return Iterator.zipKeyed(a); -} -export function f5(a, b) { - return Iterator.zipKeyed({ a }, { mode: "longest", padding: { a: b } }); -} -export function f6(a) { - return Iterator.zip(a); -} -export function f7(a, b) { - return Iterator.zipKeyed({ a }, { mode: "longest", padding: b }); -} -export const a = f1({ a: [1], b: ["a"] }).toArray(); -export const b = f2({ a: [1], b: ["a"] }).toArray(); -export const c = f3({ a: [1], b: ["a"] }).toArray(); -export const d = f4({ a: [1], b: ["a"] }).toArray(); -export const e = f5([1], 0).toArray(); -export const f = f6([[1], ["a"]]).toArray(); -export const g = f7([1], { a: 0 }).toArray(); - - -//// [iteratorZipDeclarations.d.ts] -export declare function f1>>(a: T): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; -export declare function f2>>(a: T): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; -export declare function f3>>(a: T): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; -export declare function f4(a: T): IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; -export declare function f5(a: Iterable, b: T): IteratorObject<{ - a: T; -} & {}, undefined, unknown>; -export declare function f6 | Iterator)[]>(a: T): IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; -export declare function f7(a: Iterable, b: U): IteratorObject<{ - a: T | ("a" extends infer T_1 ? T_1 extends "a" ? T_1 extends keyof U ? U[T_1] : never : never : never) | ("a" extends infer T_2 ? T_2 extends "a" ? T_2 extends keyof { [K in keyof U as {} extends Pick ? never : K]: unknown; } ? never : undefined : never : never); -} & {}, undefined, unknown>; -export declare const a: ({ - a: number; - b: string; -} & {})[]; -export declare const b: ({ - a: number | undefined; - b: string | undefined; -} & {})[]; -export declare const c: ({ - a: number | undefined; - b: string | undefined; -} & {})[]; -export declare const d: ({ - a: number; - b: string; -} & {})[]; -export declare const e: ({ - a: number; -} & {})[]; -export declare const f: [1, "a"][]; -export declare const g: ({ - a: number; -} & {})[]; diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=true).symbols b/tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=true).symbols deleted file mode 100644 index 0908a94f18793..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=true).symbols +++ /dev/null @@ -1,173 +0,0 @@ -//// [tests/cases/compiler/iteratorZipDeclarations.ts] //// - -=== iteratorZipDeclarations.ts === -export function f1>>(a: T) { ->f1 : Symbol(f1, Decl(iteratorZipDeclarations.ts, 0, 0)) ->T : Symbol(T, Decl(iteratorZipDeclarations.ts, 0, 19)) ->Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 0, 64)) ->T : Symbol(T, Decl(iteratorZipDeclarations.ts, 0, 19)) - - return Iterator.zipKeyed(a); ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 0, 64)) -} - -export function f2>>(a: T) { ->f2 : Symbol(f2, Decl(iteratorZipDeclarations.ts, 2, 1)) ->T : Symbol(T, Decl(iteratorZipDeclarations.ts, 4, 19)) ->Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 4, 64)) ->T : Symbol(T, Decl(iteratorZipDeclarations.ts, 4, 19)) - - return Iterator.zipKeyed(a, { mode: "longest" }); ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 4, 64)) ->mode : Symbol(mode, Decl(iteratorZipDeclarations.ts, 5, 33)) -} - -export function f3>>(a: T) { ->f3 : Symbol(f3, Decl(iteratorZipDeclarations.ts, 6, 1)) ->T : Symbol(T, Decl(iteratorZipDeclarations.ts, 8, 19)) ->Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 8, 64)) ->T : Symbol(T, Decl(iteratorZipDeclarations.ts, 8, 19)) - - return Iterator.zipKeyed(a, { mode: "longest", padding: {} }); ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 8, 64)) ->mode : Symbol(mode, Decl(iteratorZipDeclarations.ts, 9, 33)) ->padding : Symbol(padding, Decl(iteratorZipDeclarations.ts, 9, 50)) -} - -export function f4(a: T) { ->f4 : Symbol(f4, Decl(iteratorZipDeclarations.ts, 10, 1)) ->T : Symbol(T, Decl(iteratorZipDeclarations.ts, 12, 19)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 12, 37)) ->T : Symbol(T, Decl(iteratorZipDeclarations.ts, 12, 19)) - - return Iterator.zipKeyed(a); ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 12, 37)) -} - -export function f5(a: Iterable, b: T) { ->f5 : Symbol(f5, Decl(iteratorZipDeclarations.ts, 14, 1)) ->T : Symbol(T, Decl(iteratorZipDeclarations.ts, 16, 19)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 16, 22)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->T : Symbol(T, Decl(iteratorZipDeclarations.ts, 16, 19)) ->b : Symbol(b, Decl(iteratorZipDeclarations.ts, 16, 37)) ->T : Symbol(T, Decl(iteratorZipDeclarations.ts, 16, 19)) - - return Iterator.zipKeyed({ a }, { mode: "longest", padding: { a: b } }); ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 17, 30)) ->mode : Symbol(mode, Decl(iteratorZipDeclarations.ts, 17, 37)) ->padding : Symbol(padding, Decl(iteratorZipDeclarations.ts, 17, 54)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 17, 65)) ->b : Symbol(b, Decl(iteratorZipDeclarations.ts, 16, 37)) -} - -export function f6 | Iterator)[]>(a: T) { ->f6 : Symbol(f6, Decl(iteratorZipDeclarations.ts, 18, 1)) ->T : Symbol(T, Decl(iteratorZipDeclarations.ts, 20, 19)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 20, 81)) ->T : Symbol(T, Decl(iteratorZipDeclarations.ts, 20, 19)) - - return Iterator.zip(a); ->Iterator.zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zip : Symbol(IteratorConstructor.zip, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --) ... and 1 more) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 20, 81)) -} - -export function f7(a: Iterable, b: U) { ->f7 : Symbol(f7, Decl(iteratorZipDeclarations.ts, 22, 1)) ->T : Symbol(T, Decl(iteratorZipDeclarations.ts, 24, 19)) ->U : Symbol(U, Decl(iteratorZipDeclarations.ts, 24, 21)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 24, 33)) ->T : Symbol(T, Decl(iteratorZipDeclarations.ts, 24, 19)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 24, 44)) ->Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) ->T : Symbol(T, Decl(iteratorZipDeclarations.ts, 24, 19)) ->b : Symbol(b, Decl(iteratorZipDeclarations.ts, 24, 59)) ->U : Symbol(U, Decl(iteratorZipDeclarations.ts, 24, 21)) - - return Iterator.zipKeyed({ a }, { mode: "longest", padding: b }); ->Iterator.zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2025.iterator.d.ts, --, --)) ->zipKeyed : Symbol(IteratorConstructor.zipKeyed, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 25, 30)) ->mode : Symbol(mode, Decl(iteratorZipDeclarations.ts, 25, 37)) ->padding : Symbol(padding, Decl(iteratorZipDeclarations.ts, 25, 54)) ->b : Symbol(b, Decl(iteratorZipDeclarations.ts, 24, 59)) -} - -export const a = f1({ a: [1], b: ["a"] }).toArray(); ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 28, 12)) ->f1({ a: [1], b: ["a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->f1 : Symbol(f1, Decl(iteratorZipDeclarations.ts, 0, 0)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 28, 21)) ->b : Symbol(b, Decl(iteratorZipDeclarations.ts, 28, 29)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -export const b = f2({ a: [1], b: ["a"] }).toArray(); ->b : Symbol(b, Decl(iteratorZipDeclarations.ts, 29, 12)) ->f2({ a: [1], b: ["a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->f2 : Symbol(f2, Decl(iteratorZipDeclarations.ts, 2, 1)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 29, 21)) ->b : Symbol(b, Decl(iteratorZipDeclarations.ts, 29, 29)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -export const c = f3({ a: [1], b: ["a"] }).toArray(); ->c : Symbol(c, Decl(iteratorZipDeclarations.ts, 30, 12)) ->f3({ a: [1], b: ["a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->f3 : Symbol(f3, Decl(iteratorZipDeclarations.ts, 6, 1)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 30, 21)) ->b : Symbol(b, Decl(iteratorZipDeclarations.ts, 30, 29)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -export const d = f4({ a: [1], b: ["a"] }).toArray(); ->d : Symbol(d, Decl(iteratorZipDeclarations.ts, 31, 12)) ->f4({ a: [1], b: ["a"] }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->f4 : Symbol(f4, Decl(iteratorZipDeclarations.ts, 10, 1)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 31, 21)) ->b : Symbol(b, Decl(iteratorZipDeclarations.ts, 31, 29)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -export const e = f5([1], 0).toArray(); ->e : Symbol(e, Decl(iteratorZipDeclarations.ts, 32, 12)) ->f5([1], 0).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->f5 : Symbol(f5, Decl(iteratorZipDeclarations.ts, 14, 1)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -export const f = f6([[1], ["a"]] as const).toArray(); ->f : Symbol(f, Decl(iteratorZipDeclarations.ts, 33, 12)) ->f6([[1], ["a"]] as const).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->f6 : Symbol(f6, Decl(iteratorZipDeclarations.ts, 18, 1)) ->const : Symbol(const) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - -export const g = f7([1], { a: 0 }).toArray(); ->g : Symbol(g, Decl(iteratorZipDeclarations.ts, 34, 12)) ->f7([1], { a: 0 }).toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) ->f7 : Symbol(f7, Decl(iteratorZipDeclarations.ts, 22, 1)) ->a : Symbol(a, Decl(iteratorZipDeclarations.ts, 34, 26)) ->toArray : Symbol(IteratorObject.toArray, Decl(lib.es2025.iterator.d.ts, --, --)) - diff --git a/tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=true).types b/tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=true).types deleted file mode 100644 index 7e764cb63a919..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/iteratorZipDeclarations(exactoptionalpropertytypes=true).types +++ /dev/null @@ -1,210 +0,0 @@ -//// [tests/cases/compiler/iteratorZipDeclarations.ts] //// - -=== iteratorZipDeclarations.ts === -export function f1>>(a: T) { ->f1 : >>(a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown> ->a : T - - return Iterator.zipKeyed(a); ->Iterator.zipKeyed(a) : IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->a : T -} - -export function f2>>(a: T) { ->f2 : >>(a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown> ->a : T - - return Iterator.zipKeyed(a, { mode: "longest" }); ->Iterator.zipKeyed(a, { mode: "longest" }) : IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->a : T ->{ mode: "longest" } : { mode: "longest"; } ->mode : "longest" ->"longest" : "longest" -} - -export function f3>>(a: T) { ->f3 : >>(a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown> ->a : T - - return Iterator.zipKeyed(a, { mode: "longest", padding: {} }); ->Iterator.zipKeyed(a, { mode: "longest", padding: {} }) : IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->a : T ->{ mode: "longest", padding: {} } : { mode: "longest"; padding: {}; } ->mode : "longest" ->"longest" : "longest" ->padding : {} ->{} : {} -} - -export function f4(a: T) { ->f4 : (a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown> ->a : T - - return Iterator.zipKeyed(a); ->Iterator.zipKeyed(a) : IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->a : T -} - -export function f5(a: Iterable, b: T) { ->f5 : (a: Iterable, b: T) => IteratorObject<{ a: T; } & {}, undefined, unknown> ->a : Iterable ->b : T - - return Iterator.zipKeyed({ a }, { mode: "longest", padding: { a: b } }); ->Iterator.zipKeyed({ a }, { mode: "longest", padding: { a: b } }) : IteratorObject<{ a: T; } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->{ a } : { a: Iterable; } ->a : Iterable ->{ mode: "longest", padding: { a: b } } : { mode: "longest"; padding: { a: T; }; } ->mode : "longest" ->"longest" : "longest" ->padding : { a: T; } ->{ a: b } : { a: T; } ->a : T ->b : T -} - -export function f6 | Iterator)[]>(a: T) { ->f6 : | Iterator)[]>(a: T) => IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown> ->a : T - - return Iterator.zip(a); ->Iterator.zip(a) : IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown> ->Iterator.zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T_1, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T_1, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T_1, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T_1 extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T_1 extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->Iterator : IteratorConstructor ->zip : { (iterables: readonly [], options?: IteratorZipLongestOptions & object> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject; | Iterator) & object)[] | []>(iterables: T_1, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; | Iterator) & object)[] | [], TPadding extends readonly unknown[] | []>(iterables: T_1, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | undefined; }>; }): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; | Iterator) & object)[] | []>(iterables: T_1, options: IteratorZipLongestOptions | Iterator) & object ? U : never : never : never) | undefined; }>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<{ -readonly [K in keyof T_1]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<(T_1 extends (Iterable | Iterator) & object ? U : never)[], undefined, unknown>; | Iterator) & object>(iterables: Iterable & object, options: IteratorZipLongestOptions | Iterator) & object ? U : never) | undefined> & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject<((T_1 extends (Iterable | Iterator) & object ? U : never) | undefined)[], undefined, unknown>; } ->a : T -} - -export function f7(a: Iterable, b: U) { ->f7 : (a: Iterable, b: U) => IteratorObject<{ a: T | ("a" extends infer T_1 ? T_1 extends "a" ? T_1 extends keyof U ? U[T_1] : never : never : never) | ("a" extends infer T_2 ? T_2 extends "a" ? T_2 extends keyof { [K in keyof U as {} extends Pick ? never : K]: unknown; } ? never : undefined : never : never); } & {}, undefined, unknown> ->a : T | undefined ->a : Iterable ->b : U - - return Iterator.zipKeyed({ a }, { mode: "longest", padding: b }); ->Iterator.zipKeyed({ a }, { mode: "longest", padding: b }) : IteratorObject<{ a: T | ("a" extends infer T_1 ? T_1 extends "a" ? T_1 extends keyof U ? U[T_1] : never : never : never) | ("a" extends infer T_2 ? T_2 extends "a" ? T_2 extends keyof { [K in keyof U as {} extends Pick ? never : K]: unknown; } ? never : undefined : never : never); } & {}, undefined, unknown> ->Iterator.zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U_1 : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->Iterator : IteratorConstructor ->zipKeyed : { (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options?: IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions & { padding: TPadding & NoInfer<{ readonly [K in keyof T_1]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | undefined; }>; }): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends keyof TPadding ? TPadding[K] : never) | (K extends keyof { [K_1 in keyof TPadding as {} extends Pick ? never : K_1]: unknown; } ? never : undefined); }, undefined, unknown>; (iterables: T_1 & { [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }, options: IteratorZipLongestOptions | Iterator) & object ? U_1 : never : never : never) | undefined; } & object>> | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject> ? keyof T_1 extends never ? Record : never : { -readonly [K in keyof T_1 as undefined extends T_1[K] ? never : K]: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T_1 as undefined extends T_1[K] ? T_1[K] extends T_1[K] & undefined ? never : K : never]?: (T_1[K] extends infer T_2 ? T_2 extends T_1[K] ? T_2 extends (Iterable | Iterator) & object ? U_1 : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown>; (iterables: T_1 & ([T_1] extends [{ [K in T_1 extends unknown ? keyof T_1 : never]?: ((Iterable | Iterator) & object) | undefined; }] ? never : unknown), options?: IteratorZipLongestOptions | IteratorZipShortestOptions | IteratorZipStrictOptions): IteratorObject, undefined, unknown>; } ->{ a } : { a: Iterable; } ->a : Iterable ->{ mode: "longest", padding: b } : { mode: "longest"; padding: U; } ->mode : "longest" ->"longest" : "longest" ->padding : U ->b : U -} - -export const a = f1({ a: [1], b: ["a"] }).toArray(); ->a : ({ a: number; b: string; } & {})[] ->f1({ a: [1], b: ["a"] }).toArray() : ({ a: number; b: string; } & {})[] ->f1({ a: [1], b: ["a"] }).toArray : () => ({ a: number; b: string; } & {})[] ->f1({ a: [1], b: ["a"] }) : IteratorObject<{ a: number; b: string; } & {}, undefined, unknown> ->f1 : >>(a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown> ->{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } ->a : number[] ->[1] : number[] ->1 : 1 ->b : string[] ->["a"] : string[] ->"a" : "a" ->toArray : () => ({ a: number; b: string; } & {})[] - -export const b = f2({ a: [1], b: ["a"] }).toArray(); ->b : ({ a: number | undefined; b: string | undefined; } & {})[] ->f2({ a: [1], b: ["a"] }).toArray() : ({ a: number | undefined; b: string | undefined; } & {})[] ->f2({ a: [1], b: ["a"] }).toArray : () => ({ a: number | undefined; b: string | undefined; } & {})[] ->f2({ a: [1], b: ["a"] }) : IteratorObject<{ a: number | undefined; b: string | undefined; } & {}, undefined, unknown> ->f2 : >>(a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown> ->{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } ->a : number[] ->[1] : number[] ->1 : 1 ->b : string[] ->["a"] : string[] ->"a" : "a" ->toArray : () => ({ a: number | undefined; b: string | undefined; } & {})[] - -export const c = f3({ a: [1], b: ["a"] }).toArray(); ->c : ({ a: number | undefined; b: string | undefined; } & {})[] ->f3({ a: [1], b: ["a"] }).toArray() : ({ a: number | undefined; b: string | undefined; } & {})[] ->f3({ a: [1], b: ["a"] }).toArray : () => ({ a: number | undefined; b: string | undefined; } & {})[] ->f3({ a: [1], b: ["a"] }) : IteratorObject<{ a: number | undefined; b: string | undefined; } & {}, undefined, unknown> ->f3 : >>(a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : undefined); }, undefined, unknown> ->{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } ->a : number[] ->[1] : number[] ->1 : 1 ->b : string[] ->["a"] : string[] ->"a" : "a" ->toArray : () => ({ a: number | undefined; b: string | undefined; } & {})[] - -export const d = f4({ a: [1], b: ["a"] }).toArray(); ->d : ({ a: number; b: string; } & {})[] ->f4({ a: [1], b: ["a"] }).toArray() : ({ a: number; b: string; } & {})[] ->f4({ a: [1], b: ["a"] }).toArray : () => ({ a: number; b: string; } & {})[] ->f4({ a: [1], b: ["a"] }) : IteratorObject<{ a: number; b: string; } & {}, undefined, unknown> ->f4 : (a: T) => IteratorObject> ? keyof T extends never ? Record : never : { -readonly [K in keyof T as undefined extends T[K] ? never : K]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); } & { -readonly [K in keyof T as undefined extends T[K] ? T[K] extends T[K] & undefined ? never : K : never]?: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown> ->{ a: [1], b: ["a"] } : { a: number[]; b: string[]; } ->a : number[] ->[1] : number[] ->1 : 1 ->b : string[] ->["a"] : string[] ->"a" : "a" ->toArray : () => ({ a: number; b: string; } & {})[] - -export const e = f5([1], 0).toArray(); ->e : ({ a: number; } & {})[] ->f5([1], 0).toArray() : ({ a: number; } & {})[] ->f5([1], 0).toArray : () => ({ a: number; } & {})[] ->f5([1], 0) : IteratorObject<{ a: number; } & {}, undefined, unknown> ->f5 : (a: Iterable, b: T) => IteratorObject<{ a: T; } & {}, undefined, unknown> ->[1] : number[] ->1 : 1 ->0 : 0 ->toArray : () => ({ a: number; } & {})[] - -export const f = f6([[1], ["a"]] as const).toArray(); ->f : [1, "a"][] ->f6([[1], ["a"]] as const).toArray() : [1, "a"][] ->f6([[1], ["a"]] as const).toArray : () => [1, "a"][] ->f6([[1], ["a"]] as const) : IteratorObject<[1, "a"], undefined, unknown> ->f6 : | Iterator)[]>(a: T) => IteratorObject<{ -readonly [K in keyof T]: (T[K] extends infer T_1 ? T_1 extends T[K] ? T_1 extends (Iterable | Iterator) & object ? U : never : never : never) | (K extends never ? {}[K] : never) | (K extends never ? never : never); }, undefined, unknown> ->[[1], ["a"]] as const : readonly [readonly [1], readonly ["a"]] ->[[1], ["a"]] : readonly [readonly [1], readonly ["a"]] ->[1] : readonly [1] ->1 : 1 ->["a"] : readonly ["a"] ->"a" : "a" ->toArray : () => [1, "a"][] - -export const g = f7([1], { a: 0 }).toArray(); ->g : ({ a: number; } & {})[] ->f7([1], { a: 0 }).toArray() : ({ a: number; } & {})[] ->f7([1], { a: 0 }).toArray : () => ({ a: number; } & {})[] ->f7([1], { a: 0 }) : IteratorObject<{ a: number; } & {}, undefined, unknown> ->f7 : (a: Iterable, b: U) => IteratorObject<{ a: T | ("a" extends infer T_1 ? T_1 extends "a" ? T_1 extends keyof U ? U[T_1] : never : never : never) | ("a" extends infer T_2 ? T_2 extends "a" ? T_2 extends keyof { [K in keyof U as {} extends Pick ? never : K]: unknown; } ? never : undefined : never : never); } & {}, undefined, unknown> ->[1] : number[] ->1 : 1 ->{ a: 0 } : { a: number; } ->a : number ->0 : 0 ->toArray : () => ({ a: number; } & {})[] - diff --git a/tsc/testdata/tests/cases/compiler/iteratorZip.ts b/tsc/testdata/tests/cases/compiler/iteratorZip.ts index a2ef39a934727..e8d858cab0044 100644 --- a/tsc/testdata/tests/cases/compiler/iteratorZip.ts +++ b/tsc/testdata/tests/cases/compiler/iteratorZip.ts @@ -4,6 +4,8 @@ // @exactOptionalPropertyTypes: true, false // @declaration: true +// @filename: a.ts + declare const a1: unique symbol; const a2: [number, string][] = Iterator.zip([ @@ -67,8 +69,6 @@ const a24: { a: number; b: string; }[] = Iterator.zipKeyed(a23).toArray(); Iterator.zip([[1]], { mode: "invalid" }); -Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }); - Iterator.zip([[1]], { mode: "shortest", padding: [1] }); Iterator.zip(0); @@ -270,4 +270,97 @@ Iterator.zipKeyed(null); Iterator.zipKeyed(a107, { mode: "invalid" }); Iterator.zipKeyed(a107, { mode: "shortest", padding: {} }); Iterator.zipKeyed(a107, { mode: "longest", padding: 0 }); -Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: { a: "invalid" } }); +const a138: [number | boolean, string | undefined][] = Iterator.zip([[1], ["a"]] as const, { mode: "longest", padding: [true] }).toArray(); +const a139: { a: number | string; b: number | undefined; }[] = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: { a: "a" } }).toArray(); + +declare const a140: boolean[]; +const a141: [number | boolean | undefined, string | boolean | undefined][] = Iterator.zip([[1], ["a"]], { mode: "longest", padding: a140 }).toArray(); +const a142 = Iterator.zip(a12, { mode: "longest", padding: new Set([false]) }).toArray(); +const a143: (number | boolean | undefined)[][] = a142; +const a144: (number | undefined)[][] = a142; +const a145: (number | boolean | undefined)[][] = Iterator.zip([[1], [2, 3]], { mode: "longest", padding: new Set([false]) }).toArray(); + +declare const a146: { a: boolean; } | { b: string; }; +const a147 = Iterator.zipKeyed({ a: [1], b: [2, 3] }, { mode: "longest", padding: a146 }).toArray(); +const a148: { a: number | boolean | undefined; b: number | string | undefined; }[] = a147; +const a149: { a: number | undefined; b: number | undefined; }[] = a147; +declare const a150: [boolean] | [string, string]; +const a151: [number | boolean | string, number | string | undefined][] = Iterator.zip([[1], [2, 3]], { mode: "longest", padding: a150 }).toArray(); + +declare const a152: { mode: "longest"; padding?: { a: boolean; }; }; +const a153 = Iterator.zipKeyed({ a: [1] }, a152).toArray(); +const a154: { a: number | boolean | undefined; }[] = a153; +const a155: { a: number | boolean; }[] = a153; +declare const a156: { mode: "shortest"; } | { mode: "longest"; padding: [boolean]; } | undefined; +const a157: [number | boolean | undefined][] = Iterator.zip([[1]], a156).toArray(); +const a158: [number][] = Iterator.zip([[1]], { mode: undefined }).toArray(); +const a159: { a: number | undefined; }[] = Iterator.zipKeyed({ a: [1] }, { mode: "longest", padding: undefined }).toArray(); + +const a160: { a: number | { b: string; }; [a1]: boolean | string; }[] = Iterator.zipKeyed({ a: [1], [a1]: [true, false] }, { + mode: "longest", + padding: { a: { b: "a" }, [a1]: "a" }, +}).toArray(); +const a161: { "0": number | boolean; }[] = Iterator.zipKeyed({ "0": [1] }, { mode: "longest", padding: { 0: false } }).toArray(); +const a162: { 0: number | boolean; }[] = Iterator.zipKeyed({ 0: [1] }, { mode: "longest", padding: { "0": false } }).toArray(); +const a163 = Iterator.zipKeyed({ 0: [1] }, { mode: "longest", padding: { "01": false } }).toArray(); +const a164: { 0: number | undefined; }[] = a163; +const a165: { 0: number; }[] = a163; + +declare const a166: Record; +const a167 = Iterator.zipKeyed({ NaN: [1], Infinity: [2], "-Infinity": [3] }, { mode: "longest", padding: a166 }).toArray(); +const a168: { NaN: number | boolean | undefined; Infinity: number | boolean | undefined; "-Infinity": number | boolean | undefined; }[] = a167; +const a169: { NaN: number | undefined; Infinity: number | undefined; "-Infinity": number | undefined; }[] = a167; +const a170 = Iterator.zipKeyed(a58, { mode: "longest", padding: { a: false } }).toArray(); +const a171: Record[] = a170; +const a172: Record[] = a170; + +const a173: [number | undefined, string | undefined][] = Iterator.zip<[Iterable, Iterable]>([[1], ["a"]], { mode: "longest", padding: [0, ""] }).toArray(); +const a174: (number | undefined)[][] = Iterator.zip>(a12, { mode: "longest", padding: [0] }).toArray(); +const a175: { a: number | undefined; }[] = Iterator.zipKeyed<{ a: Iterable; }>({ a: [1] }, { mode: "longest", padding: { a: 0 } }).toArray(); +const a176: [number | boolean][] = Iterator.zip<[Iterable], [boolean]>([[1]], { mode: "longest", padding: [false] }).toArray(); +const a177: { a: number | boolean; }[] = Iterator.zipKeyed<{ a: Iterable; }, { a: boolean; }>({ a: [1] }, { mode: "longest", padding: { a: false } }).toArray(); +Iterator.zipKeyed<{ a: Iterable; }>({ a: [1] }, { mode: "longest", padding: 0 }); +Iterator.zipKeyed<{}>({}, { mode: "longest", padding: 0 }); +Iterator.zipKeyed<{ a: Iterable; }, {}>({ a: [1] }, { mode: "longest", padding: 0 }); + +// @filename: b.ts + +export function f1>>(a: T) { + return Iterator.zipKeyed(a); +} + +export function f2>>(a: T) { + return Iterator.zipKeyed(a, { mode: "longest" }); +} + +export function f3>>(a: T) { + return Iterator.zipKeyed(a, { mode: "longest", padding: {} }); +} + +export function f4(a: T) { + return Iterator.zipKeyed(a); +} + +export function f5(a: Iterable, b: U) { + return Iterator.zipKeyed({ a }, { mode: "longest", padding: { a: b } }); +} + +export function f6 | Iterator)[]>(a: T) { + return Iterator.zip(a); +} + +export function f7(a: Iterable, b: U) { + return Iterator.zipKeyed({ a }, { mode: "longest", padding: b }); +} + +export const a = f1({ a: [1], b: ["a"] }).toArray(); +export const b = f2({ a: [1], b: ["a"] }).toArray(); +export const c = f3({ a: [1], b: ["a"] }).toArray(); +export const d = f4({ a: [1], b: ["a"] }).toArray(); +export const e = f5([1], false).toArray(); +export const f = f6([[1], ["a"]] as const).toArray(); +export const g = f7([1], { a: false }).toArray(); +export const h = Iterator.zip; +export const i = Iterator.zipKeyed; +export const j = h([[1], ["a"]], { mode: "longest", padding: [false, false] }).toArray(); +export const k = i({ a: [1], b: [2, 3] }, { mode: "longest", padding: { a: false } }).toArray(); diff --git a/tsc/testdata/tests/cases/compiler/iteratorZipDeclarations.ts b/tsc/testdata/tests/cases/compiler/iteratorZipDeclarations.ts deleted file mode 100644 index 8d7d2ed6e669f..0000000000000 --- a/tsc/testdata/tests/cases/compiler/iteratorZipDeclarations.ts +++ /dev/null @@ -1,41 +0,0 @@ -// @target: esnext -// @lib: es2015, esnext.iterator -// @strict: true -// @exactOptionalPropertyTypes: true, false -// @declaration: true - -export function f1>>(a: T) { - return Iterator.zipKeyed(a); -} - -export function f2>>(a: T) { - return Iterator.zipKeyed(a, { mode: "longest" }); -} - -export function f3>>(a: T) { - return Iterator.zipKeyed(a, { mode: "longest", padding: {} }); -} - -export function f4(a: T) { - return Iterator.zipKeyed(a); -} - -export function f5(a: Iterable, b: T) { - return Iterator.zipKeyed({ a }, { mode: "longest", padding: { a: b } }); -} - -export function f6 | Iterator)[]>(a: T) { - return Iterator.zip(a); -} - -export function f7(a: Iterable, b: U) { - return Iterator.zipKeyed({ a }, { mode: "longest", padding: b }); -} - -export const a = f1({ a: [1], b: ["a"] }).toArray(); -export const b = f2({ a: [1], b: ["a"] }).toArray(); -export const c = f3({ a: [1], b: ["a"] }).toArray(); -export const d = f4({ a: [1], b: ["a"] }).toArray(); -export const e = f5([1], 0).toArray(); -export const f = f6([[1], ["a"]] as const).toArray(); -export const g = f7([1], { a: 0 }).toArray();